| bfwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) ⊦ nfwsim (CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r, λ cs, a, cs', as. min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs'))) |
⊦ bfwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) ↔ (∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as))) ∧ (∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (a = τ ⊃ r(as, cs0) ;∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ astepf(asl.last, a, as1) ∧ r(as1, cs0) ))
∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (a = τ ⊃ r(as, cs0) ;∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ astepf(asl.last, a, as1) ∧ r(as1, cs0) ) ⊦ nfwsim (CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r, λ cs, a, cs', as. min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')))
Used terms: r, astepf, astartf, cstepf, cstartf
| ⊦ bfwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r) ↔ (∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as))) ∧ (∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (a = τ ⊃ r(as, cs0) ;∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ astepf(asl.last, a, as1) ∧ r(as1, cs0) )) |
| ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (a = τ ⊃ r(as, cs0) ;∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ astepf(asl.last, a, as1) ∧ r(as1, cs0) ) ⊦ nfwsim (CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r, λ cs, a, cs', as. min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs'))) |
∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (a = τ ⊃ r(as, cs0) ;∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ astepf(asl.last, a, as1) ∧ r(as1, cs0) ), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ nfwsim (CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r, λ cs, a, cs', as. min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')))
| ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (a = τ ⊃ r(as, cs0) ;∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ astepf(asl.last, a, as1) ∧ r(as1, cs0) ), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ nfwsim (CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r, λ cs, a, cs', as. min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs'))) |
⊦ nfwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r, size10f) ↔ (∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as))) ∧ (∀ cs, a, cs', as. r(as, cs) ∧ cstepf(cs, a, cs') → r(as, cs') ∧ a = τ ∨ (∃ as'. astepf(as, a, as') ∧ r(as', cs') ∨ (∃ as'. astepf(as, τ, as') ∧ r(as', cs) ∧ size10f(cs, a, cs', as') < size10f(cs, a, cs', as))))
∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (a = τ ⊃ r(as, cs0) ;∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ astepf(asl.last, a, as1) ∧ r(as1, cs0) ) ⊦ (∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as))) ∧ (∀ cs, a, cs', as. r(as, cs) ∧ cstepf(cs, a, cs') → r(as, cs') ∧ a = τ ∨ (∃ as'. astepf(as, a, as') ∧ r(as', cs') ∨ (∃ as'. astepf(as, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')))))
Used terms: λ cs, a, cs', as. min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')), r, astepf, astartf, cstepf, cstartf
| ⊦ nfwsim(CIOAut(cstartf, cstepf), AIOAut(astartf, astepf), r, size10f) ↔ (∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as))) ∧ (∀ cs, a, cs', as. r(as, cs) ∧ cstepf(cs, a, cs') → r(as, cs') ∧ a = τ ∨ (∃ as'. astepf(as, a, as') ∧ r(as', cs') ∨ (∃ as'. astepf(as, τ, as') ∧ r(as', cs) ∧ size10f(cs, a, cs', as') < size10f(cs, a, cs', as)))) |
| ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (a = τ ⊃ r(as, cs0) ;∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ astepf(asl.last, a, as1) ∧ r(as1, cs0) ) ⊦ (∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as))) ∧ (∀ cs, a, cs', as. r(as, cs) ∧ cstepf(cs, a, cs') → r(as, cs') ∧ a = τ ∨ (∃ as'. astepf(as, a, as') ∧ r(as', cs') ∨ (∃ as'. astepf(as, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs'))))) |
cstepf(cs, a, cs'), r(as, cs), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (a = τ ⊃ r(as, cs0) ;∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ astepf(asl.last, a, as1) ∧ r(as1, cs0) ), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ ∃ as'. astepf(as, a, as') ∧ r(as', cs'), ∃ as'. astepf(as, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')), r(as, cs') ∧ a = τ
| cstepf(cs, a, cs'), r(as, cs), ∀ cs, a, cs0, as. r(as, cs) ∧ cstepf(cs, a, cs0) → (a = τ ⊃ r(as, cs0) ;∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ astepf(asl.last, a, as1) ∧ r(as1, cs0) ), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ ∃ as'. astepf(as, a, as') ∧ r(as', cs'), ∃ as'. astepf(as, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')), r(as, cs') ∧ a = τ |
cstepf(cs, a, cs'), r(as, cs), r(as, cs) ∧ cstepf(cs, a, cs') → (a = τ ⊃ r(as, cs') ;∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ astepf(asl.last, a, as1) ∧ r(as1, cs') ), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ ∃ as'. astepf(as, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')), ∃ as'. astepf(as, a, as') ∧ r(as', cs'), r(as, cs') ∧ a = τ
Used terms: cs, a, cs', as
| cstepf(cs, a, cs'), r(as, cs), r(as, cs) ∧ cstepf(cs, a, cs') → (a = τ ⊃ r(as, cs') ;∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ astepf(asl.last, a, as1) ∧ r(as1, cs') ), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ ∃ as'. astepf(as, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')), ∃ as'. astepf(as, a, as') ∧ r(as', cs'), r(as, cs') ∧ a = τ |
cstepf(cs, a, cs'), r(as, cs), (a = τ ⊃ r(as, cs') ;afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ astepf(asl.last, a, as1) ∧ r(as1, cs') ), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ ∃ as'. astepf(as, a, as') ∧ r(as', cs'), ∃ as'. astepf(as, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')), r(as, cs') ∧ a = τ
| cstepf(cs, a, cs'), r(as, cs), (a = τ ⊃ r(as, cs') ;afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ astepf(asl.last, a, as1) ∧ r(as1, cs') ), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ ∃ as'. astepf(as, a, as') ∧ r(as', cs'), ∃ as'. astepf(as, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')), r(as, cs') ∧ a = τ |
⌜al⌝ ^ = [], hd(asl) = as, a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astepf(asl.last, a, as1), cstepf(cs, a, cs'), r(as, cs), r(as1, cs'), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl → r(as, cs) ⊦ ∃ as'. astepf(as, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')), ∃ as'. astepf(as, a, as') ∧ r(as', cs'), r(as, cs') ∧ a = τ
| ⌜al⌝ ^ = [], hd(asl) = as, a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astepf(asl.last, a, as1), cstepf(cs, a, cs'), r(as, cs), r(as1, cs'), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl → r(as, cs) ⊦ ∃ as'. astepf(as, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')), ∃ as'. astepf(as, a, as') ∧ r(as', cs'), r(as, cs') ∧ a = τ |
⌜al⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astepf(asl.last, a, as1), cstepf(cs, a, cs'), r(as1, cs'), r(hd(asl), cs), ∀ as. as ∈ asl → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ ∃ as'. astepf(hd(asl), a, as') ∧ r(as', cs'), ∃ as'. astepf(hd(asl), τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl0, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl0) = hd(asl) ∧ (∀ as. as ∈ asl0 → r(as, cs)) ∧ n = # al ∧ astepf(asl0.last, a, as1) ∧ r(as1, cs'))
| ⌜al⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astepf(asl.last, a, as1), cstepf(cs, a, cs'), r(as1, cs'), r(hd(asl), cs), ∀ as. as ∈ asl → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ ∃ as'. astepf(hd(asl), a, as') ∧ r(as', cs'), ∃ as'. astepf(hd(asl), τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl0, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl0) = hd(asl) ∧ (∀ as. as ∈ asl0 → r(as, cs)) ∧ n = # al ∧ astepf(asl0.last, a, as1) ∧ r(as1, cs')) |
⌜al⌝ ^ = [], asl = as0 + asl1, a ≠ τ, asl ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astepf(asl.last, a, as1), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl → r(as, cs) ⊦ ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl0, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl0) = as0 ∧ (∀ as. as ∈ asl0 → r(as, cs)) ∧ n = # al ∧ astepf(asl0.last, a, as1) ∧ r(as1, cs')), ∃ as'. astepf(as0, a, as') ∧ r(as', cs')
Used simplifier rules: ⊦ ⌜[]⌝ = []; (s) ⊦ ¬ afrag(AIOAut(startf, stepf))([], α); (s) x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y; (elim) Used terms: asl, as0, y
| ⌜al⌝ ^ = [], asl = as0 + asl1, a ≠ τ, asl ≠ [], afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ), astepf(asl.last, a, as1), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl → r(as, cs) ⊦ ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl0, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl0) = as0 ∧ (∀ as. as ∈ asl0 → r(as, cs)) ∧ n = # al ∧ astepf(asl0.last, a, as1) ∧ r(as1, cs')), ∃ as'. astepf(as0, a, as') ∧ r(as', cs') |
⌜al⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜asl1⌝ , ⌜al⌝ ), astepf((as0 ' + asl1).last, a, as1), cstepf(cs, a, cs'), r(as1, cs'), r(as0, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs) ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs'), ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl0, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl0) = as0 ∧ (∀ as. as ∈ asl0 → r(as, cs)) ∧ n = # al ∧ astepf(asl0.last, a, as1) ∧ r(as1, cs'))
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ a ∈ b ' + x ↔ a = b ∨ a ∈ x; (s) ⊦ a + x = a ' + x; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ a ' + x ≠ []; (s)
| ⌜al⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜asl1⌝ , ⌜al⌝ ), astepf((as0 ' + asl1).last, a, as1), cstepf(cs, a, cs'), r(as1, cs'), r(as0, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs) ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs'), ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl0, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl0) = as0 ∧ (∀ as. as ∈ asl0 → r(as, cs)) ∧ n = # al ∧ astepf(asl0.last, a, as1) ∧ r(as1, cs')) |
⊦ (∃ n. pnat(n)) → pnat(min(pnat))
⌜al⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜asl1⌝ , ⌜al⌝ ), astepf((as0 ' + asl1).last, a, as1), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), (∃ n. ∃ asl0, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl0) = as0 ∧ (∀ as. as ∈ asl0 → r(as, cs)) ∧ n = # al ∧ astepf(asl0.last, a, as1) ∧ r(as1, cs')) → (∃ asl0, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl0) = as0 ∧ (∀ as. as ∈ asl0 → r(as, cs)) ∧ min (λ n. ∃ asl0, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl0) = as0 ∧ (∀ as. as ∈ asl0 → r(as, cs)) ∧ n = # al ∧ astepf(asl0.last, a, as1) ∧ r(as1, cs')) = # al ∧ astepf(asl0.last, a, as1) ∧ r(as1, cs')), ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl0, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl0) = as0 ∧ (∀ as. as ∈ asl0 → r(as, cs)) ∧ n = # al ∧ astepf(asl0.last, a, as1) ∧ r(as1, cs')), ∃ as'. astepf(as0, a, as') ∧ r(as', cs')
Used terms: λ n. ∃ asl0, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl0) = as0 ∧ (∀ as. as ∈ asl0 → r(as, cs)) ∧ n = # al ∧ astepf(asl0.last, a, as1) ∧ r(as1, cs')
| ⊦ (∃ n. pnat(n)) → pnat(min(pnat)) |
| ⌜al⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜asl1⌝ , ⌜al⌝ ), astepf((as0 ' + asl1).last, a, as1), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), (∃ n. ∃ asl0, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl0) = as0 ∧ (∀ as. as ∈ asl0 → r(as, cs)) ∧ n = # al ∧ astepf(asl0.last, a, as1) ∧ r(as1, cs')) → (∃ asl0, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl0) = as0 ∧ (∀ as. as ∈ asl0 → r(as, cs)) ∧ min (λ n. ∃ asl0, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl0) = as0 ∧ (∀ as. as ∈ asl0 → r(as, cs)) ∧ n = # al ∧ astepf(asl0.last, a, as1) ∧ r(as1, cs')) = # al ∧ astepf(asl0.last, a, as1) ∧ r(as1, cs')), ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl0, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl0) = as0 ∧ (∀ as. as ∈ asl0 → r(as, cs)) ∧ n = # al ∧ astepf(asl0.last, a, as1) ∧ r(as1, cs')), ∃ as'. astepf(as0, a, as') ∧ r(as', cs') |
⌜al⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜asl1⌝ , ⌜al⌝ ), astepf((as0 ' + asl1).last, a, as1), cstepf(cs, a, cs'), r(as1, cs'), r(as0, cs), (∃ asl0, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl0) = as0 ∧ (∀ as. as ∈ asl0 → r(as, cs)) ∧ astepf(asl0.last, a, as1) ∧ r(as1, cs')) → afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al0⌝ ) ∧ ⌜al0⌝ ^ = [] ∧ hd(asl0) = as0 ∧ (∀ as. as ∈ asl0 → r(as, cs)) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = hd(asl0) ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al0 ∧ astepf(asl0.last, a, as) ∧ r(as, cs'), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs) ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs'), ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl0, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl0) = as0 ∧ (∀ as. as ∈ asl0 → r(as, cs)) ∧ n = # al ∧ astepf(asl0.last, a, as1) ∧ r(as1, cs'))
| ⌜al⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜asl1⌝ , ⌜al⌝ ), astepf((as0 ' + asl1).last, a, as1), cstepf(cs, a, cs'), r(as1, cs'), r(as0, cs), (∃ asl0, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl0) = as0 ∧ (∀ as. as ∈ asl0 → r(as, cs)) ∧ astepf(asl0.last, a, as1) ∧ r(as1, cs')) → afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al0⌝ ) ∧ ⌜al0⌝ ^ = [] ∧ hd(asl0) = as0 ∧ (∀ as. as ∈ asl0 → r(as, cs)) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = hd(asl0) ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al0 ∧ astepf(asl0.last, a, as) ∧ r(as, cs'), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs) ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs'), ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl0, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl0) = as0 ∧ (∀ as. as ∈ asl0 → r(as, cs)) ∧ n = # al ∧ astepf(asl0.last, a, as1) ∧ r(as1, cs')) |
⌜al⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜asl1⌝ , ⌜al⌝ ), astepf((as0 ' + asl1).last, a, as1), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl0, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl0) = as0 ∧ (∀ as. as ∈ asl0 → r(as, cs)) ∧ n = # al ∧ astepf(asl0.last, a, as1) ∧ r(as1, cs')), ∃ as'. astepf(as0, a, as') ∧ r(as', cs'), ∃ asl0, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl0) = as0 ∧ (∀ as. as ∈ asl0 → r(as, cs)) ∧ astepf(asl0.last, a, as1) ∧ r(as1, cs')
⌜al⌝ ^ = [], ⌜al0⌝ ^ = [], hd(asl0) = as0, a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜asl1⌝ , ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al0⌝ ), astepf((as0 ' + asl1).last, a, as1), astepf(asl0.last, a, as), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), r(as, cs'), ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = hd(asl0) ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al0 ⊦ ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl0, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl0) = as0 ∧ (∀ as. as ∈ asl0 → r(as, cs)) ∧ n = # al ∧ astepf(asl0.last, a, as1) ∧ r(as1, cs')), ∃ as'. astepf(as0, a, as') ∧ r(as', cs')
| ⌜al⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜asl1⌝ , ⌜al⌝ ), astepf((as0 ' + asl1).last, a, as1), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl0, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl0) = as0 ∧ (∀ as. as ∈ asl0 → r(as, cs)) ∧ n = # al ∧ astepf(asl0.last, a, as1) ∧ r(as1, cs')), ∃ as'. astepf(as0, a, as') ∧ r(as', cs'), ∃ asl0, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl0) = as0 ∧ (∀ as. as ∈ asl0 → r(as, cs)) ∧ astepf(asl0.last, a, as1) ∧ r(as1, cs') |
⌜al⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜asl1⌝ , ⌜al⌝ ), astepf((as0 ' + asl1).last, a, as1), cstepf(cs, a, cs'), r(as1, cs'), r(as0, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs) ⊦ ∃ asl0, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl0) = as0 ∧ (∀ as. as ∈ asl0 → r(as, cs)) ∧ astepf(asl0.last, a, as1) ∧ r(as1, cs')
| ⌜al⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜asl1⌝ , ⌜al⌝ ), astepf((as0 ' + asl1).last, a, as1), cstepf(cs, a, cs'), r(as1, cs'), r(as0, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs) ⊦ ∃ asl0, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl0) = as0 ∧ (∀ as. as ∈ asl0 → r(as, cs)) ∧ astepf(asl0.last, a, as1) ∧ r(as1, cs') |
⌜al⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜asl1⌝ , ⌜al⌝ ), astepf((as0 ' + asl1).last, a, as1), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ afrag(AIOAut(astartf, astepf))(⌜as0 ' + asl1⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(as0 ' + asl1) = as0 ∧ (∀ as. as ∈ as0 ' + asl1 → r(as, cs)) ∧ astepf((as0 ' + asl1).last, a, as1) ∧ r(as1, cs')
Used terms: as0 ' + asl1, al, as1
| ⌜al⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜asl1⌝ , ⌜al⌝ ), astepf((as0 ' + asl1).last, a, as1), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)) ⊦ afrag(AIOAut(astartf, astepf))(⌜as0 ' + asl1⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(as0 ' + asl1) = as0 ∧ (∀ as. as ∈ as0 ' + asl1 → r(as, cs)) ∧ astepf((as0 ' + asl1).last, a, as1) ∧ r(as1, cs') |
⌜al⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜asl1⌝ , ⌜al⌝ ), astepf(asl1.last, a, as1), cstepf(cs, a, cs'), r(as1, cs'), r(as0, cs), as ∈ asl1, ¬ r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs) ⊦
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ a ∈ x → (b ' + x).last = x.last; (s) ⊦ a ∈ b ' + x ↔ a = b ∨ a ∈ x; (s) ⊦ hd(a ' + x) = a; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s)
| ⌜al⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜asl1⌝ , ⌜al⌝ ), astepf(asl1.last, a, as1), cstepf(cs, a, cs'), r(as1, cs'), r(as0, cs), as ∈ asl1, ¬ r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs) ⊦ |
Used terms: as
| ⌜al⌝ ^ = [], ⌜al0⌝ ^ = [], hd(asl0) = as0, a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜asl1⌝ , ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al0⌝ ), astepf((as0 ' + asl1).last, a, as1), astepf(asl0.last, a, as), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), r(as, cs'), ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = hd(asl0) ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al0 ⊦ ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl0, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl0) = as0 ∧ (∀ as. as ∈ asl0 → r(as, cs)) ∧ n = # al ∧ astepf(asl0.last, a, as1) ∧ r(as1, cs')), ∃ as'. astepf(as0, a, as') ∧ r(as', cs') |
⌜al0⌝ ^ = [], ⌜al⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al0⌝ ), afrag(AIOAut(astartf, astepf))(⌜hd(asl0) '⌝ + ⌜asl1⌝ , ⌜al⌝ ), astepf(asl0.last, a, as), astepf((hd(asl0) ' + asl1).last, a, as1), cstepf(cs, a, cs'), r(as, cs'), r(as1, cs'), r(hd(asl0), cs), ∀ as. as ∈ asl0 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = hd(asl0) ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al0 ⊦ ∃ as'. astepf(hd(asl0), a, as') ∧ r(as', cs'), ∃ as'. astepf(hd(asl0), τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = hd(asl0) ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs'))
| ⌜al0⌝ ^ = [], ⌜al⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al0⌝ ), afrag(AIOAut(astartf, astepf))(⌜hd(asl0) '⌝ + ⌜asl1⌝ , ⌜al⌝ ), astepf(asl0.last, a, as), astepf((hd(asl0) ' + asl1).last, a, as1), cstepf(cs, a, cs'), r(as, cs'), r(as1, cs'), r(hd(asl0), cs), ∀ as. as ∈ asl0 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = hd(asl0) ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al0 ⊦ ∃ as'. astepf(hd(asl0), a, as') ∧ r(as', cs'), ∃ as'. astepf(hd(asl0), τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = hd(asl0) ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) |
⌜al⌝ ^ = [], ⌜al0⌝ ^ = [], asl0 = as0 + asl2, a ≠ τ, asl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜asl1⌝ , ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al0⌝ ), astepf((as0 ' + asl1).last, a, as1), astepf(asl0.last, a, as), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), r(as, cs'), ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al0 ⊦ ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')), ∃ as'. astepf(as0, a, as') ∧ r(as', cs')
Used simplifier rules: ⊦ ⌜[]⌝ = []; (s) ⊦ ¬ afrag(AIOAut(startf, stepf))([], α); (s) x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y; (elim) Used terms: asl0, as0, y
| ⌜al⌝ ^ = [], ⌜al0⌝ ^ = [], asl0 = as0 + asl2, a ≠ τ, asl0 ≠ [], afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜asl1⌝ , ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜asl0⌝ , ⌜al0⌝ ), astepf((as0 ' + asl1).last, a, as1), astepf(asl0.last, a, as), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), r(as, cs'), ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl0 → r(as, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al0 ⊦ ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')), ∃ as'. astepf(as0, a, as') ∧ r(as', cs') |
⌜al0⌝ ^ = [], ⌜al⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜asl1⌝ , ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜asl2⌝ , ⌜al0⌝ ), astepf((as0 ' + asl2).last, a, as), astepf((as0 ' + asl1).last, a, as1), cstepf(cs, a, cs'), r(as, cs'), r(as1, cs'), r(as0, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs), ∀ as2. as2 ∈ asl2 → r(as2, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al0 ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs'), ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs'))
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ a ∈ b ' + x ↔ a = b ∨ a ∈ x; (s) ⊦ a + x = a ' + x; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ a ' + x ≠ []; (s)
| ⌜al0⌝ ^ = [], ⌜al⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜asl1⌝ , ⌜al⌝ ), afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜asl2⌝ , ⌜al0⌝ ), astepf((as0 ' + asl2).last, a, as), astepf((as0 ' + asl1).last, a, as1), cstepf(cs, a, cs'), r(as, cs'), r(as1, cs'), r(as0, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs), ∀ as2. as2 ∈ asl2 → r(as2, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al0 ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs'), ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) |
⌜al0⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜asl2⌝ , ⌜al0⌝ ), astepf((as0 ' + asl2).last, a, as), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), r(as, cs'), ∀ as2. as2 ∈ asl2 → r(as2, cs), ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al0 ⊦ ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')), ∃ as'. astepf(as0, a, as') ∧ r(as', cs')
| ⌜al0⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜asl2⌝ , ⌜al0⌝ ), astepf((as0 ' + asl2).last, a, as), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), r(as, cs'), ∀ as2. as2 ∈ asl2 → r(as2, cs), ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al0 ⊦ ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')), ∃ as'. astepf(as0, a, as') ∧ r(as', cs') |
⌜al0⌝ ^ = [], asl2 = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜asl2⌝ , ⌜al0⌝ ), astepf((as0 ' + asl2).last, a, as), cstepf(cs, a, cs'), r(as, cs'), r(as1, cs'), r(as0, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs), ∀ as2. as2 ∈ asl2 → r(as2, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al0 ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs'), ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs'))
⌜al0⌝ ^ = [], asl2 = as2 + asl0, a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜asl2⌝ , ⌜al0⌝ ), astepf((as0 ' + asl2).last, a, as), cstepf(cs, a, cs'), r(as, cs'), r(as1, cs'), r(as0, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs), ∀ as2. as2 ∈ asl2 → r(as2, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al0 ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs'), ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs'))
Used simplifier rules: astatelist freely generated by [], +;;
| ⌜al0⌝ ^ = [], asl2 = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜asl2⌝ , ⌜al0⌝ ), astepf((as0 ' + asl2).last, a, as), cstepf(cs, a, cs'), r(as, cs'), r(as1, cs'), r(as0, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs), ∀ as2. as2 ∈ asl2 → r(as2, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al0 ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs'), ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) |
⌜al0⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ , ⌜al0⌝ ), astepf(as0, a, as), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), r(as, cs'), ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al0 ⊦ ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')), ∃ as'. astepf(as0, a, as') ∧ r(as', cs')
Used simplifier rules: ⊦ ¬ a ∈ []; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceA-IOstatestream] ⊦ σ + [] = σ; (s) ⊦ ⌜[]⌝ = []; (s) ⊦ a '.last = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ x + [] = x; (s)
| ⌜al0⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ , ⌜al0⌝ ), astepf(as0, a, as), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), r(as, cs'), ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al0 ⊦ ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')), ∃ as'. astepf(as0, a, as') ∧ r(as', cs') |
Used terms: as
| ⌜al0⌝ ^ = [], asl2 = as2 + asl0, a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜asl2⌝ , ⌜al0⌝ ), astepf((as0 ' + asl2).last, a, as), cstepf(cs, a, cs'), r(as, cs'), r(as1, cs'), r(as0, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs), ∀ as2. as2 ∈ asl2 → r(as2, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al0 ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs'), ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) |
⌜al0⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜as2 '⌝ + ⌜asl0⌝ , ⌜al0⌝ ), astepf((as2 ' + asl0).last, a, as), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), r(as, cs'), ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al0 ⊦ ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')), ∃ as'. astepf(as0, a, as') ∧ r(as', cs')
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ a ∈ b ' + x ↔ a = b ∨ a ∈ x; (s) ⊦ a + x = a ' + x; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceA-IOstatestream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ (b ' + a ' + x).last = (a ' + x).last; (s)
| ⌜al0⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜as2 '⌝ + ⌜asl0⌝ , ⌜al0⌝ ), astepf((as2 ' + asl0).last, a, as), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), r(as, cs'), ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al0 ⊦ ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')), ∃ as'. astepf(as0, a, as') ∧ r(as', cs') |
⌜al0⌝ ^ = [], al0 = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜as2 '⌝ + ⌜asl0⌝ , ⌜al0⌝ ), astepf((as2 ' + asl0).last, a, as), cstepf(cs, a, cs'), r(as, cs'), r(as1, cs'), r(as0, cs), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al0 ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs'), ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs'))
⌜al0⌝ ^ = [], al0 = a0 + al1, a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜as2 '⌝ + ⌜asl0⌝ , ⌜al0⌝ ), astepf((as2 ' + asl0).last, a, as), cstepf(cs, a, cs'), r(as, cs'), r(as1, cs'), r(as0, cs), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al0 ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs'), ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs'))
Used simplifier rules: actionlist freely generated by [], +;;
| ⌜al0⌝ ^ = [], al0 = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜as2 '⌝ + ⌜asl0⌝ , ⌜al0⌝ ), astepf((as2 ' + asl0).last, a, as), cstepf(cs, a, cs'), r(as, cs'), r(as1, cs'), r(as0, cs), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al0 ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs'), ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) |
a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜as2 '⌝ + ⌜asl0⌝ , []), astepf((as2 ' + asl0).last, a, as), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), r(as, cs'), ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = 0 ⊦ ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')), ∃ as'. astepf(as0, a, as') ∧ r(as', cs')
Used simplifier rules: ⊦ # [] = 0; (s) ⊦ ⌜[]⌝ = []; (s) ⊦ [] ^ = []; (s)
| a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜as2 '⌝ + ⌜asl0⌝ , []), astepf((as2 ' + asl0).last, a, as), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), r(as, cs'), ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = 0 ⊦ ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')), ∃ as'. astepf(as0, a, as') ∧ r(as', cs') |
⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
Used simplifier rules: ⊦ #(σ + σ1) = # σ + # σ1; (s) ⊦ # a ' = 0 +1; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceA-IOstatestream] ⊦ # [] = ⌜0⌝ ; (s) ⊦ ⌜(* n)⌝ + ⌜(* m)⌝ = ⌜n + m⌝ ; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ n < m → (⌜(* n)⌝ = ⌜(* m)⌝ + n∞2 ↔ false); (s) add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf Used terms: [], ⌜as0 '⌝ + ⌜as2 '⌝ + ⌜asl0⌝ , astepf, astartf
| ⊦ afrag(AIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| ⌜al0⌝ ^ = [], al0 = a0 + al1, a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜as2 '⌝ + ⌜asl0⌝ , ⌜al0⌝ ), astepf((as2 ' + asl0).last, a, as), cstepf(cs, a, cs'), r(as, cs'), r(as1, cs'), r(as0, cs), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al0 ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs'), ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) |
⌜al1⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜as2 '⌝ + ⌜asl0⌝ , ⌜τ '⌝ + ⌜al1⌝ ), astepf((as2 ' + asl0).last, a, as), cstepf(cs, a, cs'), r(as, cs'), r(as1, cs'), r(as0, cs), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al1 + 1 ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs'), ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs'))
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ m +1 = m + 1; (s) ⊦ #(a ' + x) = (# x)+1; (s) ⊦ a + x = a ' + x; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ ⌜a '⌝ ^ = [] ↔ a = τ; (s) ⊦ σ0 + σ1 = [] ↔ σ0 = [] ∧ σ1 = []; (ws) ⊦ (⌜al⌝ + α2)^ = ⌜al⌝ ^ + α2 ^; (s)
| ⌜al1⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as0 '⌝ + ⌜as2 '⌝ + ⌜asl0⌝ , ⌜τ '⌝ + ⌜al1⌝ ), astepf((as2 ' + asl0).last, a, as), cstepf(cs, a, cs'), r(as, cs'), r(as1, cs'), r(as0, cs), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al1 + 1 ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs'), ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) |
⊦ afrag(AIOAut(startf, stepf))(⌜s '⌝ + σ, ⌜a '⌝ + α) ↔ stepf(s, a, hd(σ)) ∧ afrag(AIOAut(startf, stepf))(σ, α)
⌜al1⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al1⌝ ), astepf((as2 ' + asl0).last, a, as), astepf(as0, τ, hd(⌜as2 '⌝ + ⌜asl0⌝ )), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), r(as, cs'), ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al1 + 1 ⊦ ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')), ∃ as'. astepf(as0, a, as') ∧ r(as', cs')
Used terms: ⌜al1⌝ , τ, ⌜as2 '⌝ + ⌜asl0⌝ , as0, astepf, astartf
| ⊦ afrag(AIOAut(startf, stepf))(⌜s '⌝ + σ, ⌜a '⌝ + α) ↔ stepf(s, a, hd(σ)) ∧ afrag(AIOAut(startf, stepf))(σ, α) |
| ⌜al1⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al1⌝ ), astepf((as2 ' + asl0).last, a, as), astepf(as0, τ, hd(⌜as2 '⌝ + ⌜asl0⌝ )), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), r(as, cs'), ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al1 + 1 ⊦ ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')), ∃ as'. astepf(as0, a, as') ∧ r(as', cs') |
⌜al1⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al1⌝ ), astepf((as2 ' + asl0).last, a, as), astepf(as0, τ, as2), cstepf(cs, a, cs'), r(as, cs'), r(as1, cs'), r(as0, cs), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al1 + 1 ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs'), ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs'))
Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[traceA-IOstatestream] ⊦ hd(⌜a '⌝ + ⌜x⌝ ) = a; (s)
| ⌜al1⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al1⌝ ), astepf((as2 ' + asl0).last, a, as), astepf(as0, τ, as2), cstepf(cs, a, cs'), r(as, cs'), r(as1, cs'), r(as0, cs), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al1 + 1 ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs'), ∃ as'. astepf(as0, τ, as') ∧ r(as', cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as' ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) |
⌜al1⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al1⌝ ), astepf(as0, τ, as2), astepf((as2 ' + asl0).last, a, as), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), r(as, cs'), ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al1 + 1 ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs'), astepf(as0, τ, as2) ∧ r(as2, cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs'))
Used terms: as2
| ⌜al1⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al1⌝ ), astepf(as0, τ, as2), astepf((as2 ' + asl0).last, a, as), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), r(as, cs'), ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al1 + 1 ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs'), astepf(as0, τ, as2) ∧ r(as2, cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) |
⌜al1⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al1⌝ ), astepf((as2 ' + asl0).last, a, as), astepf(as0, τ, as2), cstepf(cs, a, cs'), r(as, cs'), r(as1, cs'), r(as0, cs), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al1 + 1 ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs'), r(as2, cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs'))
| ⌜al1⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al1⌝ ), astepf((as2 ' + asl0).last, a, as), astepf(as0, τ, as2), cstepf(cs, a, cs'), r(as, cs'), r(as1, cs'), r(as0, cs), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al1 + 1 ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs'), r(as2, cs) ∧ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) |
⌜al1⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al1⌝ ), astepf(as0, τ, as2), astepf((as2 ' + asl0).last, a, as), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), r(as, cs'), ¬ r(as2, cs), ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al1 + 1 ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs')
⌜al1⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al1⌝ ), astepf(as0, τ, as2), astepf((as2 ' + asl0).last, a, as), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), r(as, cs'), ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al1 + 1 ⊦ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')), ∃ as'. astepf(as0, a, as') ∧ r(as', cs')
| ⌜al1⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al1⌝ ), astepf(as0, τ, as2), astepf((as2 ' + asl0).last, a, as), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), r(as, cs'), ¬ r(as2, cs), ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al1 + 1 ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs') |
Used terms: as2
| ⌜al1⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al1⌝ ), astepf(as0, τ, as2), astepf((as2 ' + asl0).last, a, as), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), r(as, cs'), ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al1 + 1 ⊦ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) < min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')), ∃ as'. astepf(as0, a, as') ∧ r(as', cs') |
⌜al1⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al1⌝ ), astepf((as2 ' + asl0).last, a, as), astepf(as0, τ, as2), cstepf(cs, a, cs'), r(as, cs'), r(as1, cs'), r(as0, cs), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al1 + 1, min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ≤ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs')
Used simplifier rules: ⊦ m < n ↔ ¬ n ≤ m; (ss)
| ⌜al1⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al1⌝ ), astepf((as2 ' + asl0).last, a, as), astepf(as0, τ, as2), cstepf(cs, a, cs'), r(as, cs'), r(as1, cs'), r(as0, cs), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al1 + 1, min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ≤ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs') |
⊦ pnat(n) → min(pnat) ≤ n
⌜al1⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al1⌝ ), astepf(as0, τ, as2), astepf((as2 ' + asl0).last, a, as), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), r(as, cs'), (∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ # al1 = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) → min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ≤ # al1, ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al1 + 1, min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ≤ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs')
Used terms: λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs'), # al1
| ⊦ pnat(n) → min(pnat) ≤ n |
| ⌜al1⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al1⌝ ), astepf(as0, τ, as2), astepf((as2 ' + asl0).last, a, as), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), r(as, cs'), (∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ # al1 = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) → min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ≤ # al1, ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al1 + 1, min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ≤ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs') |
⌜al1⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al1⌝ ), astepf((as2 ' + asl0).last, a, as), astepf(as0, τ, as2), cstepf(cs, a, cs'), r(as, cs'), r(as1, cs'), r(as0, cs), (∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ # al1 = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) → min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ≤ # al1, ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al1 + 1, min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ≤ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs')
| ⌜al1⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al1⌝ ), astepf((as2 ' + asl0).last, a, as), astepf(as0, τ, as2), cstepf(cs, a, cs'), r(as, cs'), r(as1, cs'), r(as0, cs), (∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ # al1 = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) → min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ≤ # al1, ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al1 + 1, min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ≤ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs') |
⌜al1⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al1⌝ ), astepf(as0, τ, as2), astepf((as2 ' + asl0).last, a, as), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), r(as, cs'), ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al1 + 1, min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ≤ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs'), ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ # al1 = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')
⌜al1⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al1⌝ ), astepf(as0, τ, as2), astepf((as2 ' + asl0).last, a, as), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), r(as, cs'), ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al1 + 1, min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ≤ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ≤ # al1 ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs')
| ⌜al1⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al1⌝ ), astepf(as0, τ, as2), astepf((as2 ' + asl0).last, a, as), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), r(as, cs'), ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al1 + 1, min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ≤ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs'), ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ # al1 = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs') |
⌜al1⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al1⌝ ), astepf((as2 ' + asl0).last, a, as), astepf(as0, τ, as2), cstepf(cs, a, cs'), r(as, cs'), r(as1, cs'), r(as0, cs), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al1 + 1, min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ≤ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs'), afrag(AIOAut(astartf, astepf))(⌜as2 ' + asl0⌝ , ⌜al1⌝ ) ∧ ⌜al1⌝ ^ = [] ∧ hd(as2 ' + asl0) = as2 ∧ (∀ as. as ∈ as2 ' + asl0 → r(as, cs)) ∧ # al1 = # al1 ∧ astepf((as2 ' + asl0).last, a, as) ∧ r(as, cs')
Used terms: as2 ' + asl0, al1, as
| ⌜al1⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al1⌝ ), astepf((as2 ' + asl0).last, a, as), astepf(as0, τ, as2), cstepf(cs, a, cs'), r(as, cs'), r(as1, cs'), r(as0, cs), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al1 + 1, min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ≤ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs'), afrag(AIOAut(astartf, astepf))(⌜as2 ' + asl0⌝ , ⌜al1⌝ ) ∧ ⌜al1⌝ ^ = [] ∧ hd(as2 ' + asl0) = as2 ∧ (∀ as. as ∈ as2 ' + asl0 → r(as, cs)) ∧ # al1 = # al1 ∧ astepf((as2 ' + asl0).last, a, as) ∧ r(as, cs') |
⌜al1⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al1⌝ ), astepf(as0, τ, as2), astepf((as2 ' + asl0).last, a, as), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), r(as, cs'), ¬ r(as3, cs), ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al1 + 1, as3 = as2 ∨ as3 ∈ asl0, min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ≤ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs')
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceA-IOstatestream] ⊦ a ∈ b ' + x ↔ a = b ∨ a ∈ x; (s) ⊦ hd(a ' + x) = a; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s)
| ⌜al1⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al1⌝ ), astepf(as0, τ, as2), astepf((as2 ' + asl0).last, a, as), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), r(as, cs'), ¬ r(as3, cs), ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al1 + 1, as3 = as2 ∨ as3 ∈ asl0, min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ≤ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs') |
Used terms: as3
| ⌜al1⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al1⌝ ), astepf(as0, τ, as2), astepf((as2 ' + asl0).last, a, as), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), r(as, cs'), ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al1 + 1, min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ≤ min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ≤ # al1 ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs') |
⊦ m ≤ n ↔ (∃ n0. m + n0 = n)
⌜al1⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al1⌝ ), astepf((as2 ' + asl0).last, a, as), astepf(as0, τ, as2), cstepf(cs, a, cs'), r(as, cs'), r(as1, cs'), r(as0, cs), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs), ∃ n0. min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) + n0 = min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al1 + 1, min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ≤ # al1 ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs')
Used terms: min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs'))
| ⊦ m ≤ n ↔ (∃ n0. m + n0 = n) |
| ⌜al1⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al1⌝ ), astepf((as2 ' + asl0).last, a, as), astepf(as0, τ, as2), cstepf(cs, a, cs'), r(as, cs'), r(as1, cs'), r(as0, cs), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs), ∃ n0. min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) + n0 = min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al1 + 1, min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ≤ # al1 ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs') |
⌜al1⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al1⌝ ), astepf(as0, τ, as2), astepf((as2 ' + asl0).last, a, as), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), r(as, cs'), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) + n0 = min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')), ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al1 + 1, min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ≤ # al1 ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs')
| ⌜al1⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al1⌝ ), astepf(as0, τ, as2), astepf((as2 ' + asl0).last, a, as), cstepf(cs, a, cs'), r(as0, cs), r(as1, cs'), r(as, cs'), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) + n0 = min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')), ∀ as. as ∈ asl1 → r(as, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al1 + 1, min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as2 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) ≤ # al1 ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs') |
⌜al1⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al1⌝ ), astepf((as2 ' + asl0).last, a, as), astepf(as0, τ, as2), cstepf(cs, a, cs'), r(as, cs'), r(as1, cs'), r(as0, cs), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al1 + 1, min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) + n0 ≤ # al1 ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs')
| ⌜al1⌝ ^ = [], a ≠ τ, afrag(AIOAut(astartf, astepf))(⌜as2 '⌝ + ⌜asl0⌝ , ⌜al1⌝ ), astepf((as2 ' + asl0).last, a, as), astepf(as0, τ, as2), cstepf(cs, a, cs'), r(as, cs'), r(as1, cs'), r(as0, cs), ∀ as3. as3 = as2 ∨ as3 ∈ asl0 → r(as3, cs), ∀ cs. cstartf(cs) → (∃ as. r(as, cs) ∧ astartf(as)), ∀ as. as ∈ asl1 → r(as, cs), min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) = # al1 + 1, min (λ n. ∃ asl, al, as1. afrag(AIOAut(astartf, astepf))(⌜asl⌝ , ⌜al⌝ ) ∧ ⌜al⌝ ^ = [] ∧ hd(asl) = as0 ∧ (∀ as. as ∈ asl → r(as, cs)) ∧ n = # al ∧ astepf(asl.last, a, as1) ∧ r(as1, cs')) + n0 ≤ # al1 ⊦ ∃ as'. astepf(as0, a, as') ∧ r(as', cs') |
Used simplifier rules: ⊦ m + 1 ≤ n ↔ m < n; (s) ⊦ ¬ m + n < m; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic
The following image shows the proof tree of sequent calculus. The proved goal is at the bottom. You can click on the nodes to view additional rules. See here for details on colors in a proof tree.