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 Th75:
  w |= v implies w is-accepted-by BAutomaton(v)
proof
  set LS = LTLStates(v);
  set LT = Tran_LTL(v);
  set IS = InitS_LTL(v);
  set FS = FinalS_LTL(v);
  assume
A1: w |= v;
  ex run be sequence of LS st run.0 in IS & for n holds [[run.n,CastSeq(w,
  AtomicFamily).n],run.(n+1)] in LT & for FSet being set st FSet in FS holds {k
  where k is Element of NAT:run.k in FSet} is infinite set
  proof
    set chf = the Choice_Function of BOOL Subformulae v;
    deffunc R(set) = chosen_run(w,v,chf).k_nat($1);
A2: for x st x in NAT holds R(x) in LS;
    ex run being sequence of LS st for x st x in NAT holds run.x = R(x
    ) from FUNCT_2:sch 11(A2);
    then consider run being sequence of LS such that
A3: for x st x in NAT holds run.x = R(x);
    deffunc Run(Nat) = CastNode(run.$1,v);
A4: for n holds run.n is elementary strict LTLnode over v & Run(n) is
    elementary strict LTLnode over v
    proof
      let n;
      reconsider n as Element of NAT by ORDINAL1:def 12;
      set Rn = Run(n);
      run.n in LS;
      then consider N being Element of LTLNodes(v) such that
A5:   N = run.n and
A6:   N is elementary strict LTLnode over v;
      reconsider N as elementary strict LTLnode over v by A6;
      the LTLnew of Rn = the LTLnew of N by A5,Def16
        .= {} by Def11;
      hence thesis by A5,A6,Def11;
    end;
A7: for n holds run.n = chosen_run(w,v,chf).n
    proof
      let n;
      reconsider n as Element of NAT by ORDINAL1:def 12;
      run.n = R(n) by A3;
      hence thesis by MODELC_1:def 2;
    end;
A8: for n holds Run(n+1) is_next_of Run(n) & Shift(w,n) |= * Run(n+1)
    proof
      let n;
      set Rn = Run(n);
      reconsider Rn as elementary strict LTLnode over v by A4;
      set n1=n+1;
      set w1 = Shift(w,n);
A9:   run.n = chosen_run(w,v,chf).n by A7;
      Run(n) = CastNode(chosen_run(w,v,chf).n,v) by A7;
      then
A10:  w1 |= * ('X' Rn) by A1,Th73;
      run.n1 = chosen_run(w,v,chf).n1 by A7
        .= chosen_next(w1,v,chf,Rn) by A9,Def50;
      then Run(n1) = chosen_next(w1,v,chf,Rn) by Def16;
      hence thesis by A10,Th69;
    end;
A11: for n holds CastSeq(w,AtomicFamily).n in Label_(Run(n+1))
    proof
      let n;
      reconsider n as Element of NAT by ORDINAL1:def 12;
      set Rn1 = Run(n+1);
      set w1= Shift(w,n);
      set X = CastSeq(w,AtomicFamily).n;
      reconsider X as Subset of atomic_LTL;
      CastSeq(w1,AtomicFamily) = CastSeq(w,AtomicFamily)^\n by MODELC_2:81;
      then
A12:  CastSeq(w1,AtomicFamily).0 = CastSeq(w,AtomicFamily).(0+n) by NAT_1:def 3
;
A13:  w1 |= * Rn1 by A8;
A14:  now
        assume not Neg_atomic_LTL(Rn1) misses X;
        then Neg_atomic_LTL(Rn1) /\ X <> {} by XBOOLE_0:def 7;
        then consider a being object such that
A15:    a in Neg_atomic_LTL(Rn1) /\ X by XBOOLE_0:def 1;
        a in Neg_atomic_LTL(Rn1) by A15,XBOOLE_0:def 4;
        then consider x being LTL-formula such that
A16:    x = a & x is atomic and
A17:    ('not' x) in the LTLold of Rn1;
        ('not' x) in * Rn1 by A17,Lm1;
        then w1 |= ('not' x) by A13;
        then
A18:    w1 |/= x by MODELC_2:64;
        a in X by A15,XBOOLE_0:def 4;
        hence contradiction by A12,A16,A18,MODELC_2:63;
      end;
      atomic_LTL(Rn1) c= X
      proof
        let a be object;
        assume a in atomic_LTL(Rn1);
        then consider x being LTL-formula such that
A19:    x = a & x is atomic and
A20:    x in the LTLold of Rn1;
        x in * Rn1 by A20,Lm1;
        then w1 |= x by A13;
        hence thesis by A12,A19,MODELC_2:63;
      end;
      hence thesis by A14;
    end;
A21: for n holds [[run.n,CastSeq(w,AtomicFamily).n],run.(n+1)] in LT
    proof
      let n;
      reconsider n as Element of NAT by ORDINAL1:def 12;
      set R = Run(n);
      reconsider R as elementary strict LTLnode over v by A4;
      set n1=n+1;
      set r = run.n;
      set r1 = run.n1;
      set R1 = Run(n1);
      set gA = CastSeq(w,AtomicFamily).n;
      set y = [[r, gA], r1];
      reconsider R1 as elementary strict LTLnode over v by A4;
      [r, gA] in [: LS, AtomicFamily :] by ZFMISC_1:87;
      then [[r, gA],r1] in [:[: LS, AtomicFamily :],LS:] by ZFMISC_1:87;
      then
A22:  y is Element of [: LS, AtomicFamily, LS:] by ZFMISC_1:def 3;
      reconsider r1 as elementary strict LTLnode over v by A4;
      reconsider r as elementary strict LTLnode over v by A4;
A23:  R1 is_next_of R & gA in Label_(R1) by A8,A11;
      R = r & R1 = r1 by Def16;
      hence thesis by A22,A23;
    end;
A24: for n,H holds H in the LTLold of Run(n+1) & H is Until & Shift(w,n)|=
the_right_argument_of H implies the_right_argument_of H in the LTLold of Run(n+
    1)
    proof
      let n;
      let H;
      set n1 =n+1;
      Run(n1) = CastNode(chosen_run(w,v,chf).n1,v) by A7;
      hence thesis by A1,Th74;
    end;
A25: for FSet be set st FSet in FS holds {k where k is Element of NAT:run.
    k in FSet} is infinite set
    proof
      let FSet be set;
      set FK = {k where k is Element of NAT:run.k in FSet};
      assume FSet in FS;
      then consider x being Element of bool LS such that
A26:  FSet = x and
A27:  ex F st F is_subformula_of v & F is Until & x= FinalS_LTL(F,v);
      consider F such that
      F is_subformula_of v and
A28:  F is Until and
A29:  x= FinalS_LTL(F,v) by A27;
      set F2 = the_right_argument_of F;
      set F1 = the_left_argument_of F;
A30:  F = F1 'U' F2 by A28,MODELC_2:8;
      now
        assume not FK is infinite set;
        then consider L such that
A31:    FK = rng L by FINSEQ_1:52;
        ex m st for k st m<=k holds not k in FK
        proof
A32:      len L = 0 or 0< 0+len L;
          now
            per cases by A32,NAT_1:19;
            suppose
A33:          1<=len L;
              set LEN = len L;
              FK c= REAL
              proof
                let a be object;
                assume a in FK;
                then consider k being Element of NAT such that
A34:      a=k & run.k in FSet;
                 k in REAL by XREAL_0:def 1;
                hence thesis by A34;
              end;
              then reconsider L as FinSequence of REAL by A31,FINSEQ_1:def 4;
              set realMAX = max L;
              set iMAX = [/ realMAX \];
              set natMAX = iMAX +1;
              0<=realMAX
              proof
                set b = L.LEN;
                LEN in Seg (len L) by A33,FINSEQ_1:1;
                then LEN in dom L by FINSEQ_1:def 3;
                then b in rng L by FUNCT_1:3;
                then ex k being Element of NAT st k=b & run.k in FSet by A31;
                hence thesis by A33,RFINSEQ2:1;
              end;
              then reconsider iMAX as Nat by INT_1:53;
              iMAX +1 is Nat;
              then reconsider natMAX as Nat;
              for k st natMAX<=k holds not k in FK
              proof
                let k;
                assume
A35:            natMAX <= k;
                now
                  assume k in FK;
                  then consider i1 being object such that
A36:              i1 in dom L and
A37:              k = L.i1 by A31,FUNCT_1:def 3;
                  reconsider i1 as Element of NAT by A36;
                  i1 in Seg LEN by A36,FINSEQ_1:def 3;
                  then 1<=i1 & i1<=LEN by FINSEQ_1:1;
                  then k <= realMAX by A37,RFINSEQ2:1;
                  hence contradiction by A35,INT_1:32,XXREAL_0:2;
                end;
                hence thesis;
              end;
              hence thesis;
            end;
            suppose
              len L=0;
              then L = {};
              then for k st 0<=k holds not k in FK by A31;
              hence thesis;
            end;
          end;
          hence thesis;
        end;
        then consider m such that
A38:    for k st m<=k holds not k in FK;
A39:    for k st m<=k holds F in the LTLold of Run(k) & not F2 in the
        LTLold of Run(k)
        proof
          let k;
          assume m<=k;
          then
A40:      not k in FK by A38;
          reconsider k as Element of NAT by ORDINAL1:def 12;
          set r = run.k;
          reconsider r as elementary strict LTLnode over v by A4;
          now
            assume not (F in the LTLold of CastNode(r,v) & not F2 in the
            LTLold of CastNode(r,v));
            then r in FSet by A26,A29;
            hence contradiction by A40;
          end;
          hence thesis;
        end;
        set w1 = Shift(w,m);
        set m1=m+1;
A41:    w1 |= * Run(m1) by A8;
        m<=m1 by NAT_1:11;
        then F in the LTLold of Run(m1) by A39;
        then F in * Run(m1) by Lm1;
        then w1 |= F by A41;
        then consider h such that
        for j being Nat st j<h holds Shift(w1,j) |= F1 and
A42:    Shift(w1,h) |= F2 by A30,MODELC_2:68;
        set m2=m+h;
        set m3 = m2+1;
        m3 = m+(h+1);
        then m<=m3 by NAT_1:11;
        then
A43:    F in the LTLold of Run(m3) & not F2 in the LTLold of Run(m3) by A39;
        Shift(w,m2) |= F2 by A42,MODELC_2:80;
        hence contradiction by A24,A28,A43;
      end;
      hence thesis;
    end;
    run.0 = chosen_run(w,v,chf).0 by A7
      .= init v by Def50;
    then run.0 in IS by TARSKI:def 1;
    hence thesis by A21,A25;
  end;
  hence thesis;
end;
