| ⊦ ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0))) |
⊦ ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0)))
| ⊦ ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0))) |
∀ cs. ∃ cs0, a. (∃ a1, cs1. cstepf(cs, a1, cs1)) → cstepf(cs, a, cs0) ⊦ ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0)))
⊦ ∀ cs. ∃ cs0, a. (∃ a1, cs1. cstepf(cs, a1, cs1)) → cstepf(cs, a, cs0), ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0)))
Used formulas: ∀ cs. ∃ cs0, a. (∃ a1, cs1. cstepf(cs, a1, cs1)) → cstepf(cs, a, cs0)
| ∀ cs. ∃ cs0, a. (∃ a1, cs1. cstepf(cs, a1, cs1)) → cstepf(cs, a, cs0) ⊦ ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0))) |
∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)) ⊦ ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0)))
| ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)) ⊦ ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0))) |
∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)), ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) ⊦ ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0)))
∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)) ⊦ ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0))), ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1))
Used formulas: ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1))
| ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)), ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) ⊦ ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0))) |
∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)) ⊦ ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0))), ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)
| ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)) ⊦ ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0))), ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1) |
∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)), ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) ∧ (∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1))) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1), ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0)))
∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1), ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0))), ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) ∧ (∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)))
Used formulas: ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) ∧ (∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)))
| ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)), ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) ∧ (∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1))) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1), ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0))) |
∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)), ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) ∧ (∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1))) ⊦ ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0)))
| ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)), ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) ∧ (∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1))) ⊦ ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0))) |
∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)), ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)) ⊦ ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0))), ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)
| ∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)), ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)) ⊦ ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0))), ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1) |
∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)), ∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1), cs = (⌜λ n. ((nextcs ^^ n))(cs)⌝ to n + 1)[0] ∧ cfrag(CIOAut(cstartf, cstepf))(⌜λ n. ((nextcs ^^ n))(cs)⌝ to n + 1, ⌜λ n. nexta(((nextcs ^^ n))(cs))⌝ to n) ∧ (finp(⌜λ n. ((nextcs ^^ n))(cs)⌝ to n + 1) → ¬(∃ a, cs0. cstepf((⌜λ n. ((nextcs ^^ n))(cs)⌝ to n + 1).l.last, a, cs0)))
Used terms: ⌜λ n. ((nextcs ^^ n))(cs)⌝ to n + 1, ⌜λ n. nexta(((nextcs ^^ n))(cs))⌝ to n
| ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)), ∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1), cs = (⌜λ n. ((nextcs ^^ n))(cs)⌝ to n + 1)[0] ∧ cfrag(CIOAut(cstartf, cstepf))(⌜λ n. ((nextcs ^^ n))(cs)⌝ to n + 1, ⌜λ n. nexta(((nextcs ^^ n))(cs))⌝ to n) ∧ (finp(⌜λ n. ((nextcs ^^ n))(cs)⌝ to n + 1) → ¬(∃ a, cs0. cstepf((⌜λ n. ((nextcs ^^ n))(cs)⌝ to n + 1).l.last, a, cs0))) |
∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)), ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1), cfrag(CIOAut(cstartf, cstepf))(⌜(λ n. ((nextcs ^^ n))(cs)) to n + 1⌝ , ⌜(λ n. nexta(((nextcs ^^ n))(cs))) to n⌝ ) ∧ ¬ cstepf(((λ n. ((nextcs ^^ n))(cs)) to n + 1).last, a, cs0)
Used simplifier rules: iteratest-base: ⊦ ((nextcs ^^ 0))(cs) = cs; ⊦ ⌜x⌝ .l = x; (s) ⊦ ⌜nf⌝ to n = ⌜nf to n⌝ ; (s) ⊦ finp(⌜nf to n⌝ ); (s) ⊦ ⌜nf⌝ to n = ⌜nf to n⌝ ; (s) m < n ⊦ (nf to n)[m] = nf(m); (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m + 1 ≠ 0; (s) ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ ⌜x⌝ [n] = x[n]; (s)
| ∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)), ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1), cfrag(CIOAut(cstartf, cstepf))(⌜(λ n. ((nextcs ^^ n))(cs)) to n + 1⌝ , ⌜(λ n. nexta(((nextcs ^^ n))(cs))) to n⌝ ) ∧ ¬ cstepf(((λ n. ((nextcs ^^ n))(cs)) to n + 1).last, a, cs0) |
¬ cfrag(CIOAut(cstartf, cstepf))(⌜(λ n. ((nextcs ^^ n))(cs)) to n + 1⌝ , ⌜(λ n. nexta(((nextcs ^^ n))(cs))) to n⌝ ), ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)), ∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)
cstepf(((λ n. ((nextcs ^^ n))(cs)) to n + 1).last, a, cs0), ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)), ∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)
| ¬ cfrag(CIOAut(cstartf, cstepf))(⌜(λ n. ((nextcs ^^ n))(cs)) to n + 1⌝ , ⌜(λ n. nexta(((nextcs ^^ n))(cs))) to n⌝ ), ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)), ∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1) |
⊦ cfrag(CIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)), ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)), # ⌜(λ n. ((nextcs ^^ n))(cs)) to n + 1⌝ ≠ # ⌜(λ n. nexta(((nextcs ^^ n))(cs))) to n⌝ + ⌜1⌝ ∨ (∃ n0. ¬ ( ⌜n0⌝ < # ⌜(λ n. nexta(((nextcs ^^ n))(cs))) to n⌝ → cstepf (⌜(λ n. ((nextcs ^^ n))(cs)) to n + 1⌝ [n0], ⌜(λ n. nexta(((nextcs ^^ n))(cs))) to n⌝ [n0], ⌜(λ n. ((nextcs ^^ n))(cs)) to n + 1⌝ [n0 +1]))) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)
Used terms: ⌜(λ n. nexta(((nextcs ^^ n))(cs))) to n⌝ , ⌜(λ n. ((nextcs ^^ n))(cs)) to n + 1⌝ , cstepf, cstartf
| ⊦ cfrag(CIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| ∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)), ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)), # ⌜(λ n. ((nextcs ^^ n))(cs)) to n + 1⌝ ≠ # ⌜(λ n. nexta(((nextcs ^^ n))(cs))) to n⌝ + ⌜1⌝ ∨ (∃ n0. ¬ ( ⌜n0⌝ < # ⌜(λ n. nexta(((nextcs ^^ n))(cs))) to n⌝ → cstepf (⌜(λ n. ((nextcs ^^ n))(cs)) to n + 1⌝ [n0], ⌜(λ n. nexta(((nextcs ^^ n))(cs))) to n⌝ [n0], ⌜(λ n. ((nextcs ^^ n))(cs)) to n + 1⌝ [n0 +1]))) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1) |
n0 < n, ¬ cstepf(((nextcs ^^ n0))(cs), nexta(((nextcs ^^ n0))(cs)), nextcs(((nextcs ^^ n0))(cs))), ∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)), ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)
Used simplifier rules: iteratest-rec: ⊦ ((nextcs ^^ (n + 1)))(cs) = nextcs(((nextcs ^^ n))(cs)); ⊦ m < n → n ≠ 0; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic m < n ⊦ (nf to n)[m] = nf(m); (s) ⊦ m < n → (n ≤ m ↔ false); (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ m + n < m + n0 ↔ n < n0; (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ m +1 = m + 1; (s) m < n ⊦ (nf to n)[m] = nf(m); (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ m < n → ¬ n < m; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ # ⌜nf to n⌝ = ⌜n⌝ ; (s) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf ⊦ ⌜n⌝ = ⌜n0⌝ ↔ n = n0; (s) ⊦ n∞ + ⌜0⌝ = n∞; (s) ⊦ m ≤ n → (⌜(* n)⌝ + n∞1 = ⌜(* m)⌝ + n∞2 ↔ ⌜n - m⌝ + n∞1 = n∞2); (s) ⊦ ⌜m + n⌝ = ⌜m⌝ + ⌜n⌝ ; (s) ⊦ # ⌜nf to n⌝ = ⌜n⌝ ; (s)
| n0 < n, ¬ cstepf(((nextcs ^^ n0))(cs), nexta(((nextcs ^^ n0))(cs)), nextcs(((nextcs ^^ n0))(cs))), ∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)), ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1) |
n0 < n, ¬ cstepf(((nextcs ^^ n0))(cs), nexta(((nextcs ^^ n0))(cs)), nextcs(((nextcs ^^ n0))(cs))), n0 < n → (∃ a1, cs1. cstepf(((nextcs ^^ n0))(cs), a1, cs1)), ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)), ∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)
Used terms: n0
| n0 < n, ¬ cstepf(((nextcs ^^ n0))(cs), nexta(((nextcs ^^ n0))(cs)), nextcs(((nextcs ^^ n0))(cs))), n0 < n → (∃ a1, cs1. cstepf(((nextcs ^^ n0))(cs), a1, cs1)), ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)), ∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1) |
n0 < n, cstepf(((nextcs ^^ n0))(cs), a1, cs1), ¬ cstepf(((nextcs ^^ n0))(cs), nexta(((nextcs ^^ n0))(cs)), nextcs(((nextcs ^^ n0))(cs))), ∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)), ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)
| n0 < n, cstepf(((nextcs ^^ n0))(cs), a1, cs1), ¬ cstepf(((nextcs ^^ n0))(cs), nexta(((nextcs ^^ n0))(cs)), nextcs(((nextcs ^^ n0))(cs))), ∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)), ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1) |
n0 < n, cstepf(((nextcs ^^ n0))(cs), a1, cs1), ¬ cstepf(((nextcs ^^ n0))(cs), nexta(((nextcs ^^ n0))(cs)), nextcs(((nextcs ^^ n0))(cs))), (∃ a1, cs1. cstepf(((nextcs ^^ n0))(cs), a1, cs1)) → cstepf(((nextcs ^^ n0))(cs), nexta(((nextcs ^^ n0))(cs)), nextcs(((nextcs ^^ n0))(cs))), ∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)
Used terms: ((nextcs ^^ n0))(cs)
| n0 < n, cstepf(((nextcs ^^ n0))(cs), a1, cs1), ¬ cstepf(((nextcs ^^ n0))(cs), nexta(((nextcs ^^ n0))(cs)), nextcs(((nextcs ^^ n0))(cs))), (∃ a1, cs1. cstepf(((nextcs ^^ n0))(cs), a1, cs1)) → cstepf(((nextcs ^^ n0))(cs), nexta(((nextcs ^^ n0))(cs)), nextcs(((nextcs ^^ n0))(cs))), ∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1) |
n0 < n, cstepf(((nextcs ^^ n0))(cs), a1, cs1), ¬ cstepf(((nextcs ^^ n0))(cs), nexta(((nextcs ^^ n0))(cs)), nextcs(((nextcs ^^ n0))(cs))), ∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1), ∃ a1, cs1. cstepf(((nextcs ^^ n0))(cs), a1, cs1)
| n0 < n, cstepf(((nextcs ^^ n0))(cs), a1, cs1), ¬ cstepf(((nextcs ^^ n0))(cs), nexta(((nextcs ^^ n0))(cs)), nextcs(((nextcs ^^ n0))(cs))), ∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1), ∃ a1, cs1. cstepf(((nextcs ^^ n0))(cs), a1, cs1) |
Used terms: a1, cs1
| cstepf(((λ n. ((nextcs ^^ n))(cs)) to n + 1).last, a, cs0), ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)), ∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1) |
cstepf(((λ n. ((nextcs ^^ n))(cs)) to n + 1).last, a, cs0), ∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)), ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)
| cstepf(((λ n. ((nextcs ^^ n))(cs)) to n + 1).last, a, cs0), ∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)), ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1) |
⊦ nf to m + 1 = (nf to m) + nf(m) '
cstepf((((λ n. ((nextcs ^^ n))(cs)) to n) + ((nextcs ^^ n))(cs) ').last, a, cs0), ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)), ∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)
Used terms: n, λ n. ((nextcs ^^ n))(cs)
| ⊦ nf to m + 1 = (nf to m) + nf(m) ' |
| cstepf((((λ n. ((nextcs ^^ n))(cs)) to n) + ((nextcs ^^ n))(cs) ').last, a, cs0), ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)), ∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1) |
cstepf(((nextcs ^^ n))(cs), a, cs0), ∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)), ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[traceC-IOstatestream] ⊦ (x + a ').last = a; (s)
| cstepf(((nextcs ^^ n))(cs), a, cs0), ∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)), ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1) |
Used terms: a, cs0
| ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1), ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0))), ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) ∧ (∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1))) |
∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)) ⊦ ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) ∧ (∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1))), ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0))), ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)
| ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)) ⊦ ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) ∧ (∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1))), ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0))), ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1) |
⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1), ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0))), ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) ∧ (∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)))
| ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1), ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0))), ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) ∧ (∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1))) |
∀ n1, cstepf, nextcs, cs, cstartf. n1 < n → true → (∃ a1, cs1. cstepf(((nextcs ^^ n1))(cs), a1, cs1)) ∨ (∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0)))) ∨ (∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) ∧ (∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)))) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1), ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0))), ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) ∧ (∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)))
Used simplifier rules: <; (wellfounded) Used terms: n
| ∀ n1, cstepf, nextcs, cs, cstartf. n1 < n → true → (∃ a1, cs1. cstepf(((nextcs ^^ n1))(cs), a1, cs1)) ∨ (∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0)))) ∨ (∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) ∧ (∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)))) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1), ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0))), ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) ∧ (∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1))) |
∀ n1, cstepf, nextcs, cs, cstartf. n1 < n → true → (∃ a1, cs1. cstepf(((nextcs ^^ n1))(cs), a1, cs1)) ∨ (∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0)))) ∨ (∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) ∧ (∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)))) ⊦ ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) ∧ (∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1))), ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0))), ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)
| ∀ n1, cstepf, nextcs, cs, cstartf. n1 < n → true → (∃ a1, cs1. cstepf(((nextcs ^^ n1))(cs), a1, cs1)) ∨ (∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0)))) ∨ (∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) ∧ (∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)))) ⊦ ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) ∧ (∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1))), ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0))), ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1) |
∀ n1, cstepf, nextcs, cs, cstartf. n1 < n → true → (∃ a1, cs1. cstepf(((nextcs ^^ n1))(cs), a1, cs1)) ∨ (∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0)))) ∨ (∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) ∧ (∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)))) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1), ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0))), ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) ∧ (∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1))), ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) ∧ (∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)))
Used terms: n
| ∀ n1, cstepf, nextcs, cs, cstartf. n1 < n → true → (∃ a1, cs1. cstepf(((nextcs ^^ n1))(cs), a1, cs1)) ∨ (∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0)))) ∨ (∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) ∧ (∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)))) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1), ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0))), ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) ∧ (∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1))), ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) ∧ (∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1))) |
n0 < n, ∀ n1, cstepf, nextcs, cs, cstartf. n1 < n → true → (∃ a1, cs1. cstepf(((nextcs ^^ n1))(cs), a1, cs1)) ∨ (∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0)))) ∨ (∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) ∧ (∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)))) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n0))(cs), a1, cs1), ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1), ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0))), ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) ∧ (∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)))
Used simplifier rules: ⊦ m < n → n ≠ 0; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic
| n0 < n, ∀ n1, cstepf, nextcs, cs, cstartf. n1 < n → true → (∃ a1, cs1. cstepf(((nextcs ^^ n1))(cs), a1, cs1)) ∨ (∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0)))) ∨ (∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) ∧ (∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1)))) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n0))(cs), a1, cs1), ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1), ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0))), ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) ∧ (∀ m. m < n → (∃ a1, cs1. cstepf(((nextcs ^^ m))(cs), a1, cs1))) |
Used terms: n0, cstepf, nextcs, cs, cstartf
| ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)) ⊦ ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0))), ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) |
∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)) ⊦ ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)), ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0)))
| ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)) ⊦ ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)), ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0))) |
∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)) ⊦ ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)), cs = ⌜λ n. ((nextcs ^^ n))(cs)⌝ [0] ∧ cfrag(CIOAut(cstartf, cstepf))(⌜λ n. ((nextcs ^^ n))(cs)⌝ , ⌜λ n. nexta(((nextcs ^^ n))(cs))⌝ ) ∧ (finp(⌜λ n. ((nextcs ^^ n))(cs)⌝ ) → ¬(∃ a, cs0. cstepf(⌜λ n. ((nextcs ^^ n))(cs)⌝ .l.last, a, cs0)))
Used terms: ⌜λ n. ((nextcs ^^ n))(cs)⌝ , ⌜λ n. nexta(((nextcs ^^ n))(cs))⌝
| ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)) ⊦ ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)), cs = ⌜λ n. ((nextcs ^^ n))(cs)⌝ [0] ∧ cfrag(CIOAut(cstartf, cstepf))(⌜λ n. ((nextcs ^^ n))(cs)⌝ , ⌜λ n. nexta(((nextcs ^^ n))(cs))⌝ ) ∧ (finp(⌜λ n. ((nextcs ^^ n))(cs)⌝ ) → ¬(∃ a, cs0. cstepf(⌜λ n. ((nextcs ^^ n))(cs)⌝ .l.last, a, cs0))) |
¬ cfrag(CIOAut(cstartf, cstepf))(⌜λ n. ((nextcs ^^ n))(cs)⌝ , ⌜λ n. nexta(((nextcs ^^ n))(cs))⌝ ), ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)) ⊦ ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1))
Used simplifier rules: iteratest-base: ⊦ ((nextcs ^^ 0))(cs) = cs; ⊦ ¬ finp(⌜nf⌝ ); (s) ⊦ ⌜nf⌝ [n] = nf(n); (s)
| ¬ cfrag(CIOAut(cstartf, cstepf))(⌜λ n. ((nextcs ^^ n))(cs)⌝ , ⌜λ n. nexta(((nextcs ^^ n))(cs))⌝ ), ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)) ⊦ ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) |
⊦ cfrag(CIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)), # ⌜λ n. ((nextcs ^^ n))(cs)⌝ ≠ # ⌜λ n. nexta(((nextcs ^^ n))(cs))⌝ + ⌜1⌝ ∨ (∃ n. ¬ ( ⌜n⌝ < # ⌜λ n. nexta(((nextcs ^^ n))(cs))⌝ → cstepf(⌜λ n. ((nextcs ^^ n))(cs)⌝ [n], ⌜λ n. nexta(((nextcs ^^ n))(cs))⌝ [n], ⌜λ n. ((nextcs ^^ n))(cs)⌝ [n +1]))) ⊦ ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1))
Used terms: ⌜λ n. nexta(((nextcs ^^ n))(cs))⌝ , ⌜λ n. ((nextcs ^^ n))(cs)⌝ , cstepf, cstartf
| ⊦ cfrag(CIOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)), # ⌜λ n. ((nextcs ^^ n))(cs)⌝ ≠ # ⌜λ n. nexta(((nextcs ^^ n))(cs))⌝ + ⌜1⌝ ∨ (∃ n. ¬ ( ⌜n⌝ < # ⌜λ n. nexta(((nextcs ^^ n))(cs))⌝ → cstepf(⌜λ n. ((nextcs ^^ n))(cs)⌝ [n], ⌜λ n. nexta(((nextcs ^^ n))(cs))⌝ [n], ⌜λ n. ((nextcs ^^ n))(cs)⌝ [n +1]))) ⊦ ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) |
¬ cstepf(((nextcs ^^ n))(cs), nexta(((nextcs ^^ n))(cs)), nextcs(((nextcs ^^ n))(cs))), ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)) ⊦ ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1))
Used simplifier rules: iteratest-rec: ⊦ ((nextcs ^^ (n + 1)))(cs) = nextcs(((nextcs ^^ n))(cs)); c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ⌜nf⌝ [n] = nf(n); (s) ⊦ m +1 = m + 1; (s) ⊦ ⌜nf⌝ [n] = nf(n); (s) ⊦ ⌜m⌝ < ∞; (s) ⊦ # ⌜nf⌝ = ∞; (s) add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf ⊦ ⌜m⌝ + ∞ = ∞; (s) ⊦ # ⌜nf⌝ = ∞; (s)
| ¬ cstepf(((nextcs ^^ n))(cs), nexta(((nextcs ^^ n))(cs)), nextcs(((nextcs ^^ n))(cs))), ∀ cs0. (∃ a1, cs1. cstepf(cs0, a1, cs1)) → cstepf(cs0, nexta(cs0), nextcs(cs0)) ⊦ ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) |
¬ cstepf(((nextcs ^^ n))(cs), nexta(((nextcs ^^ n))(cs)), nextcs(((nextcs ^^ n))(cs))), (∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) → cstepf(((nextcs ^^ n))(cs), nexta(((nextcs ^^ n))(cs)), nextcs(((nextcs ^^ n))(cs))) ⊦ ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1))
Used terms: ((nextcs ^^ n))(cs)
| ¬ cstepf(((nextcs ^^ n))(cs), nexta(((nextcs ^^ n))(cs)), nextcs(((nextcs ^^ n))(cs))), (∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) → cstepf(((nextcs ^^ n))(cs), nexta(((nextcs ^^ n))(cs)), nextcs(((nextcs ^^ n))(cs))) ⊦ ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)) |
¬ cstepf(((nextcs ^^ n))(cs), nexta(((nextcs ^^ n))(cs)), nextcs(((nextcs ^^ n))(cs))) ⊦ ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)), ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)
| ¬ cstepf(((nextcs ^^ n))(cs), nexta(((nextcs ^^ n))(cs)), nextcs(((nextcs ^^ n))(cs))) ⊦ ∃ n. ¬(∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)), ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1) |
¬ cstepf(((nextcs ^^ n))(cs), nexta(((nextcs ^^ n))(cs)), nextcs(((nextcs ^^ n))(cs))), ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)
Used terms: n
| ¬ cstepf(((nextcs ^^ n))(cs), nexta(((nextcs ^^ n))(cs)), nextcs(((nextcs ^^ n))(cs))), ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1) |
cstepf(((nextcs ^^ n))(cs), a1, cs1), ¬ cstepf(((nextcs ^^ n))(cs), nexta(((nextcs ^^ n))(cs)), nextcs(((nextcs ^^ n))(cs))) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1)
| cstepf(((nextcs ^^ n))(cs), a1, cs1), ¬ cstepf(((nextcs ^^ n))(cs), nexta(((nextcs ^^ n))(cs)), nextcs(((nextcs ^^ n))(cs))) ⊦ ∃ a1, cs1. cstepf(((nextcs ^^ n))(cs), a1, cs1) |
Used terms: a1, cs1
| ⊦ ∀ cs. ∃ cs0, a. (∃ a1, cs1. cstepf(cs, a1, cs1)) → cstepf(cs, a, cs0), ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0))) |
cstepf(cs0, a1, cs1) ⊦ ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0))), ∃ cs1, a. cstepf(cs0, a, cs1)
| cstepf(cs0, a1, cs1) ⊦ ∃ cσ, α. cs = cσ[0] ∧ cfrag(CIOAut(cstartf, cstepf))(cσ, α) ∧ (finp(cσ) → ¬(∃ a, cs0. cstepf(cσ.l.last, a, cs0))), ∃ cs1, a. cstepf(cs0, a, cs1) |
Used terms: cs1, a1
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.