| a ≠ τ, move(IOAut(startf, stepf))(s, ⌜a '⌝ , s2) ⊦ ∃ s0, s1. move(IOAut(startf, stepf))(s, [], s0) ∧ stepf(s0, a, s1) ∧ move(IOAut(startf, stepf))(s1, [], s2) |
a ≠ τ, move(IOAut(startf, stepf))(s, ⌜a '⌝ , s2) ⊦ ∃ s0, s1. move(IOAut(startf, stepf))(s, [], s0) ∧ stepf(s0, a, s1) ∧ move(IOAut(startf, stepf))(s1, [], s2)
| a ≠ τ, move(IOAut(startf, stepf))(s, ⌜a '⌝ , s2) ⊦ ∃ s0, s1. move(IOAut(startf, stepf))(s, [], s0) ∧ stepf(s0, a, s1) ∧ move(IOAut(startf, stepf))(s1, [], s2) |
⊦ move(IOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. frag*(IOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β)
a ≠ τ, ∃ α, sl. frag*(IOAut(startf, stepf))(⌜sl⌝ , α) ∧ s = sl[0] ∧ s2 = sl.last ∧ α ^ = ⌜a '⌝ ⊦ ∃ s0, s1. move(IOAut(startf, stepf))(s, [], s0) ∧ stepf(s0, a, s1) ∧ move(IOAut(startf, stepf))(s1, [], s2)
Used terms: s2, ⌜a '⌝ , s, stepf, startf
| ⊦ move(IOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. frag*(IOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β) |
| a ≠ τ, ∃ α, sl. frag*(IOAut(startf, stepf))(⌜sl⌝ , α) ∧ s = sl[0] ∧ s2 = sl.last ∧ α ^ = ⌜a '⌝ ⊦ ∃ s0, s1. move(IOAut(startf, stepf))(s, [], s0) ∧ stepf(s0, a, s1) ∧ move(IOAut(startf, stepf))(s1, [], s2) |
⌜al⌝ ^ = ⌜a '⌝ , a ≠ τ, frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ) ⊦ ∃ s0, s1. move(IOAut(startf, stepf))(sl[0], [], s0) ∧ stepf(s0, a, s1) ∧ move(IOAut(startf, stepf))(s1, [], sl.last)
Used simplifier rules: fragstar: ⊦ frag*(IOAut(startf, stepf))(σ, β) ↔ frag(IOAut(startf, stepf))(σ, β) ∧ finp(β); ⊦ finp(⌜x⌝ ); (s) stream-fin-forward: ⊦ finp(σ) → (∃ x. ⌜x⌝ = σ); (forward) from specification stream-basic[actionstream]
| ⌜al⌝ ^ = ⌜a '⌝ , a ≠ τ, frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ) ⊦ ∃ s0, s1. move(IOAut(startf, stepf))(sl[0], [], s0) ∧ stepf(s0, a, s1) ∧ move(IOAut(startf, stepf))(s1, [], sl.last) |
∀ n. ⌜n⌝ < # β → β[n] = τ ⊦ β ^ = []
⌜al⌝ ^ = ⌜a '⌝ , a ≠ τ, frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ) ⊦ ∀ n. ⌜n⌝ < # ⌜al⌝ → ⌜al⌝ [n] = τ, ∃ s0, s1. move(IOAut(startf, stepf))(sl[0], [], s0) ∧ stepf(s0, a, s1) ∧ move(IOAut(startf, stepf))(s1, [], sl.last)
Used simplifier rules: ⊦ ⌜x⌝ = [] ↔ x = []; (s) ⊦ a ' ≠ []; (s) Used terms: ⌜al⌝
| ∀ n. ⌜n⌝ < # β → β[n] = τ ⊦ β ^ = [] |
| ⌜al⌝ ^ = ⌜a '⌝ , a ≠ τ, frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ) ⊦ ∀ n. ⌜n⌝ < # ⌜al⌝ → ⌜al⌝ [n] = τ, ∃ s0, s1. move(IOAut(startf, stepf))(sl[0], [], s0) ∧ stepf(s0, a, s1) ∧ move(IOAut(startf, stepf))(s1, [], sl.last) |
⌜al⌝ ^ = ⌜a '⌝ , al[n] ≠ τ, a ≠ τ, al ≠ [], n < # al, frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ) ⊦ ∃ s0, s1. move(IOAut(startf, stepf))(sl[0], [], s0) ∧ stepf(s0, a, s1) ∧ move(IOAut(startf, stepf))(s1, [], sl.last)
Used simplifier rules: ⊦ # x = 0 ↔ x = []; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ ⌜x⌝ [n] = x[n]; (s)
| ⌜al⌝ ^ = ⌜a '⌝ , al[n] ≠ τ, a ≠ τ, al ≠ [], n < # al, frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ) ⊦ ∃ s0, s1. move(IOAut(startf, stepf))(sl[0], [], s0) ∧ stepf(s0, a, s1) ∧ move(IOAut(startf, stepf))(s1, [], sl.last) |
⌜al⌝ ^ = ⌜a '⌝ , al[n] ≠ τ, a ≠ τ, al ≠ [], n < # al, frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ) ⊦ move(IOAut(startf, stepf))(sl[0], [], sl[n]) ∧ stepf(sl[n], a, sl[n + 1]) ∧ move(IOAut(startf, stepf))(sl[n + 1], [], sl.last)
Used terms: sl[n], sl[n + 1]
| ⌜al⌝ ^ = ⌜a '⌝ , al[n] ≠ τ, a ≠ τ, al ≠ [], n < # al, frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ) ⊦ move(IOAut(startf, stepf))(sl[0], [], sl[n]) ∧ stepf(sl[n], a, sl[n + 1]) ∧ move(IOAut(startf, stepf))(sl[n + 1], [], sl.last) |
⊦ frag(IOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
# ⌜sl⌝ = # ⌜al⌝ + ⌜1⌝ , ⌜al⌝ ^ = ⌜a '⌝ , al[n] ≠ τ, a ≠ τ, al ≠ [], n < # al, ∀ n. ⌜n⌝ < # ⌜al⌝ → stepf(⌜sl⌝ [n], ⌜al⌝ [n], ⌜sl⌝ [n +1]) ⊦ move(IOAut(startf, stepf))(sl[0], [], sl[n]) ∧ stepf(sl[n], a, sl[n + 1]) ∧ move(IOAut(startf, stepf))(sl[n + 1], [], sl.last)
Used terms: ⌜al⌝ , ⌜sl⌝ , stepf, startf
| ⊦ frag(IOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| # ⌜sl⌝ = # ⌜al⌝ + ⌜1⌝ , ⌜al⌝ ^ = ⌜a '⌝ , al[n] ≠ τ, a ≠ τ, al ≠ [], n < # al, ∀ n. ⌜n⌝ < # ⌜al⌝ → stepf(⌜sl⌝ [n], ⌜al⌝ [n], ⌜sl⌝ [n +1]) ⊦ move(IOAut(startf, stepf))(sl[0], [], sl[n]) ∧ stepf(sl[n], a, sl[n + 1]) ∧ move(IOAut(startf, stepf))(sl[n + 1], [], sl.last) |
# al + 1 = # sl, ⌜al⌝ ^ = ⌜a '⌝ , al[n] ≠ τ, a ≠ τ, al ≠ [], n < # al, ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ move(IOAut(startf, stepf))(sl[0], [], sl[n]) ∧ stepf(sl[n], a, sl[n + 1]) ∧ move(IOAut(startf, stepf))(sl[n + 1], [], sl.last)
Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ m +1 = m + 1; (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (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⌝ + ⌜m⌝ = ⌜n0⌝ ↔ n + m = n0; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s)
| # al + 1 = # sl, ⌜al⌝ ^ = ⌜a '⌝ , al[n] ≠ τ, a ≠ τ, al ≠ [], n < # al, ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ move(IOAut(startf, stepf))(sl[0], [], sl[n]) ∧ stepf(sl[n], a, sl[n + 1]) ∧ move(IOAut(startf, stepf))(sl[n + 1], [], sl.last) |
# al + 1 = # sl, ⌜al⌝ ^ = ⌜a '⌝ , al = (al to n + 1) + (al from n + 1), al[n] ≠ τ, a ≠ τ, al ≠ [], n < # al, ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ move(IOAut(startf, stepf))(sl[0], [], sl[n]) ∧ stepf(sl[n], a, sl[n + 1]) ∧ move(IOAut(startf, stepf))(sl[n + 1], [], sl.last)
# al + 1 = # sl, ⌜al⌝ ^ = ⌜a '⌝ , al[n] ≠ τ, a ≠ τ, al ≠ (al to n + 1) + (al from n + 1), al ≠ [], n < # al, ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ move(IOAut(startf, stepf))(sl[0], [], sl[n]) ∧ stepf(sl[n], a, sl[n + 1]) ∧ move(IOAut(startf, stepf))(sl[n + 1], [], sl.last)
Used formulas: al = (al to n + 1) + (al from n + 1)
| # al + 1 = # sl, ⌜al⌝ ^ = ⌜a '⌝ , al = (al to n + 1) + (al from n + 1), al[n] ≠ τ, a ≠ τ, al ≠ [], n < # al, ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ move(IOAut(startf, stepf))(sl[0], [], sl[n]) ∧ stepf(sl[n], a, sl[n + 1]) ∧ move(IOAut(startf, stepf))(sl[n + 1], [], sl.last) |
# al + 1 = # sl, ⌜(al to n + 1) + (al from n + 1)⌝ ^ = ⌜a '⌝ , al[n] ≠ τ, a ≠ τ, al ≠ [], n < # al, ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ move(IOAut(startf, stepf))(sl[0], [], sl[n]) ∧ stepf(sl[n], a, sl[n + 1]) ∧ move(IOAut(startf, stepf))(sl[n + 1], [], sl.last)
| # al + 1 = # sl, ⌜(al to n + 1) + (al from n + 1)⌝ ^ = ⌜a '⌝ , al[n] ≠ τ, a ≠ τ, al ≠ [], n < # al, ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ move(IOAut(startf, stepf))(sl[0], [], sl[n]) ∧ stepf(sl[n], a, sl[n + 1]) ∧ move(IOAut(startf, stepf))(sl[n + 1], [], sl.last) |
# al + 1 = # sl, ⌜al to n + 1⌝ ^ + ⌜al from n + 1⌝ ^ = ⌜a '⌝ , al[n] ≠ τ, a ≠ τ, al ≠ [], n < # al, ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ move(IOAut(startf, stepf))(sl[0], [], sl[n]) ∧ stepf(sl[n], a, sl[n + 1]) ∧ move(IOAut(startf, stepf))(sl[n + 1], [], sl.last)
Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ (⌜al⌝ + α2)^ = ⌜al⌝ ^ + α2 ^; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s)
| # al + 1 = # sl, ⌜al to n + 1⌝ ^ + ⌜al from n + 1⌝ ^ = ⌜a '⌝ , al[n] ≠ τ, a ≠ τ, al ≠ [], n < # al, ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ move(IOAut(startf, stepf))(sl[0], [], sl[n]) ∧ stepf(sl[n], a, sl[n + 1]) ∧ move(IOAut(startf, stepf))(sl[n + 1], [], sl.last) |
m < # x ⊦ x to m + 1 = (x to m) + x[m] '
⌜(al to n) + al[n] '⌝ ^ + ⌜al from n + 1⌝ ^ = ⌜a '⌝ , # al + 1 = # sl, al[n] ≠ τ, a ≠ τ, al ≠ [], n < # al, ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ move(IOAut(startf, stepf))(sl[0], [], sl[n]) ∧ stepf(sl[n], a, sl[n + 1]) ∧ move(IOAut(startf, stepf))(sl[n + 1], [], sl.last)
Used terms: n, al
| m < # x ⊦ x to m + 1 = (x to m) + x[m] ' |
| ⌜(al to n) + al[n] '⌝ ^ + ⌜al from n + 1⌝ ^ = ⌜a '⌝ , # al + 1 = # sl, al[n] ≠ τ, a ≠ τ, al ≠ [], n < # al, ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ move(IOAut(startf, stepf))(sl[0], [], sl[n]) ∧ stepf(sl[n], a, sl[n + 1]) ∧ move(IOAut(startf, stepf))(sl[n + 1], [], sl.last) |
# al + 1 = # sl, (⌜al to n⌝ ^ + ⌜al[n] '⌝ ) + ⌜al from n + 1⌝ ^ = ⌜a '⌝ , al[n] ≠ τ, a ≠ τ, al ≠ [], n < # al, ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ move(IOAut(startf, stepf))(sl[0], [], sl[n]) ∧ stepf(sl[n], a, sl[n + 1]) ∧ move(IOAut(startf, stepf))(sl[n + 1], [], sl.last)
Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ a ≠ τ → ⌜a '⌝ ^ = ⌜a '⌝ ; (s) ⊦ (⌜al⌝ + α2)^ = ⌜al⌝ ^ + α2 ^; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[actionstream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s)
| # al + 1 = # sl, (⌜al to n⌝ ^ + ⌜al[n] '⌝ ) + ⌜al from n + 1⌝ ^ = ⌜a '⌝ , al[n] ≠ τ, a ≠ τ, al ≠ [], n < # al, ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ move(IOAut(startf, stepf))(sl[0], [], sl[n]) ∧ stepf(sl[n], a, sl[n + 1]) ∧ move(IOAut(startf, stepf))(sl[n + 1], [], sl.last) |
⊦ σ0 = σ1 ↔ # σ0 = # σ1 ∧ (∀ n. ⌜n⌝ < # σ0 → σ0[n] = σ1[n])
#((⌜al to n⌝ ^ + ⌜al[n] '⌝ ) + ⌜al from n + 1⌝ ^) = # ⌜a '⌝ , # al + 1 = # sl, al[n] ≠ τ, a ≠ τ, al ≠ [], n < # al, ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]), ∀ n0. ⌜n0⌝ < #((⌜al to n⌝ ^ + ⌜al[n] '⌝ ) + ⌜al from n + 1⌝ ^) → ((⌜al to n⌝ ^ + ⌜al[n] '⌝ ) + ⌜al from n + 1⌝ ^)[n0] = ⌜a '⌝ [n0] ⊦ move(IOAut(startf, stepf))(sl[0], [], sl[n]) ∧ stepf(sl[n], a, sl[n + 1]) ∧ move(IOAut(startf, stepf))(sl[n + 1], [], sl.last)
Used terms: ⌜a '⌝ , (⌜al to n⌝ ^ + ⌜al[n] '⌝ ) + ⌜al from n + 1⌝ ^
| ⊦ σ0 = σ1 ↔ # σ0 = # σ1 ∧ (∀ n. ⌜n⌝ < # σ0 → σ0[n] = σ1[n]) |
| #((⌜al to n⌝ ^ + ⌜al[n] '⌝ ) + ⌜al from n + 1⌝ ^) = # ⌜a '⌝ , # al + 1 = # sl, al[n] ≠ τ, a ≠ τ, al ≠ [], n < # al, ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]), ∀ n0. ⌜n0⌝ < #((⌜al to n⌝ ^ + ⌜al[n] '⌝ ) + ⌜al from n + 1⌝ ^) → ((⌜al to n⌝ ^ + ⌜al[n] '⌝ ) + ⌜al from n + 1⌝ ^)[n0] = ⌜a '⌝ [n0] ⊦ move(IOAut(startf, stepf))(sl[0], [], sl[n]) ∧ stepf(sl[n], a, sl[n + 1]) ∧ move(IOAut(startf, stepf))(sl[n + 1], [], sl.last) |
# al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], al[n] ≠ τ, al ≠ [], n < # al, ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ move(IOAut(startf, stepf))(sl[0], [], sl[n]) ∧ stepf(sl[n], al[n], sl[n + 1]) ∧ move(IOAut(startf, stepf))(sl[n + 1], [], sl.last)
Used simplifier rules: ⊦ a '[0] = a; (s) ⊦ ⌜x⌝ [n] = x[n]; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[actionstream] ⊦ σ + [] = σ; (s) ⊦ [] + σ = σ; (s) ⊦ ⌜n⌝ = ⌜n0⌝ ↔ n = n0; (s) ⊦ ⌜0⌝ < n∞ ↔ n∞ ≠ ⌜0⌝ ; (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 c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ ⌜(* n)⌝ + ⌜(* m)⌝ = ⌜n + m⌝ ; (s) ⊦ # [] = ⌜0⌝ ; (s) ⊦ ⌜n⌝ < ⌜1⌝ + n∞ ↔ ¬ n∞ < ⌜n⌝ ; (s) ⊦ # a ' = 0 +1; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s) ⊦ # σ = ⌜0⌝ ↔ σ = []; (s) ⊦ n∞ + n∞1 = ⌜0⌝ ↔ n∞ = ⌜0⌝ ∧ n∞1 = ⌜0⌝ ; (ws) ⊦ m ≤ n → (⌜(* n)⌝ = ⌜(* m)⌝ + n∞2 ↔ ⌜n - m⌝ = n∞2); (s)
| # al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], al[n] ≠ τ, al ≠ [], n < # al, ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ move(IOAut(startf, stepf))(sl[0], [], sl[n]) ∧ stepf(sl[n], al[n], sl[n + 1]) ∧ move(IOAut(startf, stepf))(sl[n + 1], [], sl.last) |
# al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], n < # al, n < # al → stepf(sl[n], al[n], sl[n + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ move(IOAut(startf, stepf))(sl[0], [], sl[n]) ∧ stepf(sl[n], al[n], sl[n + 1]) ∧ move(IOAut(startf, stepf))(sl[n + 1], [], sl.last)
Used terms: n
| # al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], n < # al, n < # al → stepf(sl[n], al[n], sl[n + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ move(IOAut(startf, stepf))(sl[0], [], sl[n]) ∧ stepf(sl[n], al[n], sl[n + 1]) ∧ move(IOAut(startf, stepf))(sl[n + 1], [], sl.last) |
# al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], al[n] ≠ τ, al ≠ [], n < # al, stepf(sl[n], al[n], sl[n + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ move(IOAut(startf, stepf))(sl[0], [], sl[n]) ∧ move(IOAut(startf, stepf))(sl[n + 1], [], sl.last)
| # al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], al[n] ≠ τ, al ≠ [], n < # al, stepf(sl[n], al[n], sl[n + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ move(IOAut(startf, stepf))(sl[0], [], sl[n]) ∧ move(IOAut(startf, stepf))(sl[n + 1], [], sl.last) |
# al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], n < # al, stepf(sl[n], al[n], sl[n + 1]), ¬ move(IOAut(startf, stepf))(sl[0], [], sl[n]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦
# al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], n < # al, stepf(sl[n], al[n], sl[n + 1]), ¬ move(IOAut(startf, stepf))(sl[n + 1], [], sl.last), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦
| # al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], n < # al, stepf(sl[n], al[n], sl[n + 1]), ¬ move(IOAut(startf, stepf))(sl[0], [], sl[n]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ |
⊦ move(IOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. frag*(IOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β)
# al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], al[n] ≠ τ, al ≠ [], n < # al, stepf(sl[n], al[n], sl[n + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]), ∀ α, sl0. ¬(frag*(IOAut(startf, stepf))(⌜sl0⌝ , α) ∧ sl[0] = sl0[0] ∧ sl[n] = sl0.last ∧ α ^ = []) ⊦
Used terms: sl[n], [], sl[0], stepf, startf
| ⊦ move(IOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. frag*(IOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β) |
| # al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], al[n] ≠ τ, al ≠ [], n < # al, stepf(sl[n], al[n], sl[n + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]), ∀ α, sl0. ¬(frag*(IOAut(startf, stepf))(⌜sl0⌝ , α) ∧ sl[0] = sl0[0] ∧ sl[n] = sl0.last ∧ α ^ = []) ⊦ |
# al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], n < # al, stepf(sl[n], al[n], sl[n + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]), ∀ α, sl0. ¬ frag(IOAut(startf, stepf))(⌜sl0⌝ , α) ∨ ¬ finp(α) ∨ sl[0] ≠ sl0[0] ∨ sl[n] ≠ sl0.last ∨ α ^ ≠ [] ⊦
Used simplifier rules: fragstar: ⊦ frag*(IOAut(startf, stepf))(σ, β) ↔ frag(IOAut(startf, stepf))(σ, β) ∧ finp(β);
| # al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], n < # al, stepf(sl[n], al[n], sl[n + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]), ∀ α, sl0. ¬ frag(IOAut(startf, stepf))(⌜sl0⌝ , α) ∨ ¬ finp(α) ∨ sl[0] ≠ sl0[0] ∨ sl[n] ≠ sl0.last ∨ α ^ ≠ [] ⊦ |
# al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], al[n] ≠ τ, al ≠ [], n < # al, stepf(sl[n], al[n], sl[n + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]), ¬ frag(IOAut(startf, stepf))(⌜sl to n + 1⌝ , ⌜al to n⌝ ) ∨ ¬ finp(⌜al to n⌝ ) ∨ sl[0] ≠ (sl to n + 1)[0] ∨ sl[n] ≠ (sl to n + 1).last ∨ ⌜al to n⌝ ^ ≠ [] ⊦
Used terms: ⌜al to n⌝ , sl to n + 1
| # al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], al[n] ≠ τ, al ≠ [], n < # al, stepf(sl[n], al[n], sl[n + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]), ¬ frag(IOAut(startf, stepf))(⌜sl to n + 1⌝ , ⌜al to n⌝ ) ∨ ¬ finp(⌜al to n⌝ ) ∨ sl[0] ≠ (sl to n + 1)[0] ∨ sl[n] ≠ (sl to n + 1).last ∨ ⌜al to n⌝ ^ ≠ [] ⊦ |
# al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], n < # al, stepf(sl[n], al[n], sl[n + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]), ¬ frag(IOAut(startf, stepf))(⌜sl to n + 1⌝ , ⌜al to n⌝ ) ∨ sl[n] ≠ (sl to n + 1).last ⊦
Used simplifier rules: ¬ # x < n, m < n ⊦ (x to n)[m] = x[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) ⊦ m = m0 + n0 ∧ n < n0 → ¬ m < m0 + n; (s) ⊦ finp(⌜x⌝ ); (s)
| # al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], n < # al, stepf(sl[n], al[n], sl[n + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]), ¬ frag(IOAut(startf, stepf))(⌜sl to n + 1⌝ , ⌜al to n⌝ ) ∨ sl[n] ≠ (sl to n + 1).last ⊦ |
m < # x ⊦ x to m + 1 = (x to m) + x[m] '
# al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], al[n] ≠ τ, al ≠ [], n < # al, n < # sl, stepf(sl[n], al[n], sl[n + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]), ¬ frag(IOAut(startf, stepf))(⌜(sl to n) + sl[n] '⌝ , ⌜al to n⌝ ) ∨ sl[n] ≠ ((sl to n) + sl[n] ').last ⊦
Used simplifier rules: ⊦ m < n ↔ ¬ n ≤ m; (ss) fle-01: ⊦ m ≤ n ∧ n < n0 → m < n0; (forward) from specification nat lf-02: ⊦ m < n ∧ m = n0 → n0 < n; (forward) from specification nat-basic ⊦ ¬ m + n < m; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic Used terms: n, sl
| m < # x ⊦ x to m + 1 = (x to m) + x[m] ' |
| # al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], al[n] ≠ τ, al ≠ [], n < # al, n < # sl, stepf(sl[n], al[n], sl[n + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]), ¬ frag(IOAut(startf, stepf))(⌜(sl to n) + sl[n] '⌝ , ⌜al to n⌝ ) ∨ sl[n] ≠ ((sl to n) + sl[n] ').last ⊦ |
# al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], al[n] ≠ τ, al ≠ [], sl ≠ [], n < # al, n < # sl, stepf(sl[n], al[n], sl[n + 1]), ¬ frag(IOAut(startf, stepf))(⌜sl to n⌝ + ⌜sl[n] '⌝ , ⌜al to n⌝ ), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦
Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m < n → ¬ n < m; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ # x = 0 ↔ x = []; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ (x + a ').last = a; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s)
| # al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], al[n] ≠ τ, al ≠ [], sl ≠ [], n < # al, n < # sl, stepf(sl[n], al[n], sl[n + 1]), ¬ frag(IOAut(startf, stepf))(⌜sl to n⌝ + ⌜sl[n] '⌝ , ⌜al to n⌝ ), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ |
⊦ frag(IOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
# al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], sl ≠ [], n < # sl, n < # al, stepf(sl[n], al[n], sl[n + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]), #(⌜sl to n⌝ + ⌜sl[n] '⌝ ) ≠ # ⌜al to n⌝ + ⌜1⌝ ∨ (∃ n0. ¬(⌜n0⌝ < # ⌜al to n⌝ → stepf((⌜sl to n⌝ + ⌜sl[n] '⌝ )[n0], ⌜al to n⌝ [n0], (⌜sl to n⌝ + ⌜sl[n] '⌝ )[n0 +1]))) ⊦
Used terms: ⌜al to n⌝ , ⌜sl to n⌝ + ⌜sl[n] '⌝ , stepf, startf
| ⊦ frag(IOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| # al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], sl ≠ [], n < # sl, n < # al, stepf(sl[n], al[n], sl[n + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]), #(⌜sl to n⌝ + ⌜sl[n] '⌝ ) ≠ # ⌜al to n⌝ + ⌜1⌝ ∨ (∃ n0. ¬(⌜n0⌝ < # ⌜al to n⌝ → stepf((⌜sl to n⌝ + ⌜sl[n] '⌝ )[n0], ⌜al to n⌝ [n0], (⌜sl to n⌝ + ⌜sl[n] '⌝ )[n0 +1]))) ⊦ |
# al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], al[n] ≠ τ, al ≠ [], sl ≠ [], n0 + 1 < # al, n < # al, n < # sl, n0 < n, n0 < # al, n0 < # sl, stepf(sl[n], al[n], sl[n + 1]), ¬ stepf(((sl to n) + sl[n] ')[n0], al[n0], ((sl to n) + sl[n] ')[n0 + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦
Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m < n → ¬ n < m; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ m +1 = m + 1; (s) ⊦ m = m0 + n0 ∧ n < n0 → m0 + n < m; (s) ⊦ m < n → n ≠ 0; (s) trans: ⊦ n < n0 ∧ n0 < n1 → n < n1; (forward) from specification nat-basic lf: ⊦ m < n ∧ n < n0 → m +1 < n0; (forward) from specification nat-basic f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[IOstatestream] ⊦ (⌜x⌝ + ⌜x0⌝ )[m] = (x + x0)[m]; (s) ¬ # x < n, m < n ⊦ (x to n)[m] = x[m]; (s) ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ¬ # x < n ⊦ #(x to n) = n; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (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) ⊦ # a ' = 0 +1; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ¬ # x < n ⊦ #(x to n) = n; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s)
| # al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], al[n] ≠ τ, al ≠ [], sl ≠ [], n0 + 1 < # al, n < # al, n < # sl, n0 < n, n0 < # al, n0 < # sl, stepf(sl[n], al[n], sl[n + 1]), ¬ stepf(((sl to n) + sl[n] ')[n0], al[n0], ((sl to n) + sl[n] ')[n0 + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ |
⊦ n < # x → (x + y)[n] = x[n]
# al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], sl ≠ [], n0 < # sl, n0 < # al, n0 < n, n < # sl, n < # al, n0 + 1 < # al, n0 < #(sl to n), stepf(sl[n], al[n], sl[n + 1]), ¬ stepf((sl to n)[n0], al[n0], ((sl to n) + sl[n] ')[n0 + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦
Used simplifier rules: ⊦ m < n → ¬ n < m; (s) ¬ # x < n ⊦ #(x to n) = n; (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ m < n → (n ≤ m ↔ false); (s) Used terms: n0, sl[n] ', sl to n
| ⊦ n < # x → (x + y)[n] = x[n] |
| # al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], sl ≠ [], n0 < # sl, n0 < # al, n0 < n, n < # sl, n < # al, n0 + 1 < # al, n0 < #(sl to n), stepf(sl[n], al[n], sl[n + 1]), ¬ stepf((sl to n)[n0], al[n0], ((sl to n) + sl[n] ')[n0 + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ |
# al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], al[n] ≠ τ, al ≠ [], sl ≠ [], n0 + 1 < # al, n < # al, n < # sl, n0 < # al, n0 < # sl, n0 < n, stepf(sl[n], al[n], sl[n + 1]), ¬ stepf(sl[n0], al[n0], ((sl to n) + sl[n] ')[n0 + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦
Used simplifier rules: ¬ # x < n, m < n ⊦ (x to n)[m] = x[m]; (s) ⊦ m < n → ¬ n < m; (s) ¬ # x < n ⊦ #(x to n) = n; (s)
| # al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], al[n] ≠ τ, al ≠ [], sl ≠ [], n0 + 1 < # al, n < # al, n < # sl, n0 < # al, n0 < # sl, n0 < n, stepf(sl[n], al[n], sl[n + 1]), ¬ stepf(sl[n0], al[n0], ((sl to n) + sl[n] ')[n0 + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ |
⊦ n < # x → (x + y)[n] = x[n]
# al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], sl ≠ [], n0 < n, n0 < # sl, n0 < # al, n < # sl, n < # al, n0 + 1 < # al, stepf(sl[n], al[n], sl[n + 1]), ¬ n0 + 1 < #(sl to n), ¬ stepf(sl[n0], al[n0], ((sl to n) + sl[n] ')[n0 + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦
# al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], sl ≠ [], n0 < n, n0 < # sl, n0 < # al, n < # sl, n < # al, n0 + 1 < # al, n0 + 1 < #(sl to n), stepf(sl[n], al[n], sl[n + 1]), ¬ stepf(sl[n0], al[n0], (sl to n)[n0 + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦
Used terms: n0 + 1, sl[n] ', sl to n
| ⊦ n < # x → (x + y)[n] = x[n] |
| # al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], sl ≠ [], n0 < n, n0 < # sl, n0 < # al, n < # sl, n < # al, n0 + 1 < # al, stepf(sl[n], al[n], sl[n + 1]), ¬ n0 + 1 < #(sl to n), ¬ stepf(sl[n0], al[n0], ((sl to n) + sl[n] ')[n0 + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ |
# al + 1 = # sl, ⌜al to n0 + 1⌝ ^ = [], ⌜al from 2 + n0⌝ ^ = [], al[n0 + 1] ≠ τ, al ≠ [], sl ≠ [], n0 < # sl, n0 < # al, n0 + 1 < # al, stepf(sl[n0 + 1], al[n0 + 1], sl[2 + n0]), ¬ stepf(sl[n0], al[n0], ((sl to n0 + 1) + sl[n0 + 1] ')[n0 + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦
Used simplifier rules: a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ m = m0 + n0 ∧ n < n0 → m0 + n < m; (s) ⊦ ¬ n < n; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ m + 1 ≤ n ↔ m < n; (s) ⊦ m + n ≤ m + n0 ↔ n ≤ n0; (s) lf-02: ⊦ m < n ∧ m = n0 → n0 < n; (forward) from specification nat-basic lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic eqle-one: ⊦ m = n + 1 ∧ n < n0 → m ≤ n0; (forward) from specification nat ⊦ m < n → (n ≤ m + 1 ↔ n = m + 1); (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) ¬ # x < n ⊦ #(x to n) = n; (s) ⊦ m < n → ¬ n < m; (s)
| # al + 1 = # sl, ⌜al to n0 + 1⌝ ^ = [], ⌜al from 2 + n0⌝ ^ = [], al[n0 + 1] ≠ τ, al ≠ [], sl ≠ [], n0 < # sl, n0 < # al, n0 + 1 < # al, stepf(sl[n0 + 1], al[n0 + 1], sl[2 + n0]), ¬ stepf(sl[n0], al[n0], ((sl to n0 + 1) + sl[n0 + 1] ')[n0 + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ |
# al + 1 = # sl, ⌜al from 2 + n0⌝ ^ = [], ⌜al to n0 + 1⌝ ^ = [], al[n0 + 1] ≠ τ, al ≠ [], sl ≠ [], n0 + 1 < # al, n0 < # al, n0 < # sl, stepf(sl[n0 + 1], al[n0 + 1], sl[2 + n0]), ¬ stepf(sl[n0], al[n0], ((sl to n0 + 1) + sl[n0 + 1] ')[n0 + 1]), n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦
Used terms: n0
| # al + 1 = # sl, ⌜al from 2 + n0⌝ ^ = [], ⌜al to n0 + 1⌝ ^ = [], al[n0 + 1] ≠ τ, al ≠ [], sl ≠ [], n0 + 1 < # al, n0 < # al, n0 < # sl, stepf(sl[n0 + 1], al[n0 + 1], sl[2 + n0]), ¬ stepf(sl[n0], al[n0], ((sl to n0 + 1) + sl[n0 + 1] ')[n0 + 1]), n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ |
# al + 1 = # sl, ⌜al to n0 + 1⌝ ^ = [], ⌜al from 2 + n0⌝ ^ = [], al[n0 + 1] ≠ τ, al ≠ [], sl ≠ [], n0 < # sl, n0 < # al, n0 + 1 < # al, stepf(sl[n0 + 1], al[n0 + 1], sl[2 + n0]), stepf(sl[n0], al[n0], sl[n0 + 1]), ¬ stepf(sl[n0], al[n0], ((sl to n0 + 1) + sl[n0 + 1] ')[n0 + 1]) ⊦
| # al + 1 = # sl, ⌜al to n0 + 1⌝ ^ = [], ⌜al from 2 + n0⌝ ^ = [], al[n0 + 1] ≠ τ, al ≠ [], sl ≠ [], n0 < # sl, n0 < # al, n0 + 1 < # al, stepf(sl[n0 + 1], al[n0 + 1], sl[2 + n0]), stepf(sl[n0], al[n0], sl[n0 + 1]), ¬ stepf(sl[n0], al[n0], ((sl to n0 + 1) + sl[n0 + 1] ')[n0 + 1]) ⊦ |
⊦ ¬ n < # x → (x + y)[n] = y[n - # x]
Used simplifier rules: ⊦ m + n < m + n0 ↔ n < n0; (s) ⊦ m = m0 + n0 ∧ n < n0 → ¬ m < m0 + n; (s) ¬ # x < n ⊦ #(x to n) = n; (s) ⊦ m + n - n + n1 = m - n1; (s) ⊦ m - m = 0; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ a '[0] = a; (s) Used terms: sl to n0 + 1, sl[n0 + 1] ', n0 + 1
| ⊦ ¬ n < # x → (x + y)[n] = y[n - # x] |
| # al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], sl ≠ [], n0 < n, n0 < # sl, n0 < # al, n < # sl, n < # al, n0 + 1 < # al, n0 + 1 < #(sl to n), stepf(sl[n], al[n], sl[n + 1]), ¬ stepf(sl[n0], al[n0], (sl to n)[n0 + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ |
# al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], al[n] ≠ τ, al ≠ [], sl ≠ [], 2 + n0 < # al, 2 + n0 < # sl, n < # al, n < # sl, n0 < # al, n0 < # sl, n0 < n, n0 + 1 < n, n0 + 1 < # al, stepf(sl[n], al[n], sl[n + 1]), ¬ stepf(sl[n0], al[n0], sl[n0 + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦
Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m + n < m0 → m + n < m0 + n0; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ m = m0 + n0 ∧ n < n0 → m0 + n < m; (s) ⊦ m +1 = m + 1; (s) trans: ⊦ n < n0 ∧ n0 < n1 → n < n1; (forward) from specification nat-basic lf: ⊦ m < n ∧ n < n0 → m +1 < n0; (forward) from specification nat-basic ¬ # x < n, m < n ⊦ (x to n)[m] = x[m]; (s) ⊦ m < n → ¬ n < m; (s) ¬ # x < n ⊦ #(x to n) = n; (s)
| # al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], al[n] ≠ τ, al ≠ [], sl ≠ [], 2 + n0 < # al, 2 + n0 < # sl, n < # al, n < # sl, n0 < # al, n0 < # sl, n0 < n, n0 + 1 < n, n0 + 1 < # al, stepf(sl[n], al[n], sl[n + 1]), ¬ stepf(sl[n0], al[n0], sl[n0 + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ |
Used terms: n0
| # al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], n < # al, stepf(sl[n], al[n], sl[n + 1]), ¬ move(IOAut(startf, stepf))(sl[n + 1], [], sl.last), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ |
⊦ move(IOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. frag*(IOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β)
# al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], al[n] ≠ τ, al ≠ [], n < # al, stepf(sl[n], al[n], sl[n + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]), ∀ α, sl0. ¬(frag*(IOAut(startf, stepf))(⌜sl0⌝ , α) ∧ sl[n + 1] = sl0[0] ∧ sl.last = sl0.last ∧ α ^ = []) ⊦
Used terms: sl.last, [], sl[n + 1], stepf, startf
| ⊦ move(IOAut(startf, stepf))(s1, β, s2) ↔ (∃ α, sl. frag*(IOAut(startf, stepf))(⌜sl⌝ , α) ∧ s1 = sl[0] ∧ s2 = sl.last ∧ α ^ = β) |
| # al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], al[n] ≠ τ, al ≠ [], n < # al, stepf(sl[n], al[n], sl[n + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]), ∀ α, sl0. ¬(frag*(IOAut(startf, stepf))(⌜sl0⌝ , α) ∧ sl[n + 1] = sl0[0] ∧ sl.last = sl0.last ∧ α ^ = []) ⊦ |
# al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], n < # al, stepf(sl[n], al[n], sl[n + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]), ∀ α, sl0. ¬ frag(IOAut(startf, stepf))(⌜sl0⌝ , α) ∨ ¬ finp(α) ∨ sl[n + 1] ≠ sl0[0] ∨ sl.last ≠ sl0.last ∨ α ^ ≠ [] ⊦
Used simplifier rules: fragstar: ⊦ frag*(IOAut(startf, stepf))(σ, β) ↔ frag(IOAut(startf, stepf))(σ, β) ∧ finp(β);
| # al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], n < # al, stepf(sl[n], al[n], sl[n + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]), ∀ α, sl0. ¬ frag(IOAut(startf, stepf))(⌜sl0⌝ , α) ∨ ¬ finp(α) ∨ sl[n + 1] ≠ sl0[0] ∨ sl.last ≠ sl0.last ∨ α ^ ≠ [] ⊦ |
# al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], al[n] ≠ τ, al ≠ [], n < # al, stepf(sl[n], al[n], sl[n + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]), ¬ frag(IOAut(startf, stepf))(⌜sl from n + 1⌝ , ⌜al from n + 1⌝ ) ∨ ¬ finp(⌜al from n + 1⌝ ) ∨ sl[n + 1] ≠ (sl from n + 1)[0] ∨ sl.last ≠ (sl from n + 1).last ∨ ⌜al from n + 1⌝ ^ ≠ [] ⊦
Used terms: ⌜al from n + 1⌝ , sl from n + 1
| # al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], al[n] ≠ τ, al ≠ [], n < # al, stepf(sl[n], al[n], sl[n + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]), ¬ frag(IOAut(startf, stepf))(⌜sl from n + 1⌝ , ⌜al from n + 1⌝ ) ∨ ¬ finp(⌜al from n + 1⌝ ) ∨ sl[n + 1] ≠ (sl from n + 1)[0] ∨ sl.last ≠ (sl from n + 1).last ∨ ⌜al from n + 1⌝ ^ ≠ [] ⊦ |
# al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], n < # al, stepf(sl[n], al[n], sl[n + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]), ¬ frag(IOAut(startf, stepf))(⌜sl from n + 1⌝ , ⌜al from n + 1⌝ ) ∨ sl.last ≠ (sl from n + 1).last ⊦
Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic m + m0 < # x ⊦ (x from m)[m0] = x[m + m0]; (s) ⊦ m = m0 + n0 ∧ n < n0 → m0 + n < m; (s) ⊦ finp(⌜x⌝ ); (s)
| # al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], n < # al, stepf(sl[n], al[n], sl[n + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]), ¬ frag(IOAut(startf, stepf))(⌜sl from n + 1⌝ , ⌜al from n + 1⌝ ) ∨ sl.last ≠ (sl from n + 1).last ⊦ |
⊦ frag(IOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1]))
# al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], al[n] ≠ τ, al ≠ [], n < # al, stepf(sl[n], al[n], sl[n + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]), ¬ ( # ⌜sl from n + 1⌝ = # ⌜al from n + 1⌝ + ⌜1⌝ ∧ (∀ n0. ⌜n0⌝ < # ⌜al from n + 1⌝ → stepf(⌜sl from n + 1⌝ [n0], ⌜al from n + 1⌝ [n0], ⌜sl from n + 1⌝ [n0 +1]))) ∨ sl.last ≠ (sl from n + 1).last ⊦
Used terms: ⌜al from n + 1⌝ , ⌜sl from n + 1⌝ , stepf, startf
| ⊦ frag(IOAut(startf, stepf))(σ, β) ↔ # σ = # β + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # β → stepf(σ[n], β[n], σ[n +1])) |
| # al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], al[n] ≠ τ, al ≠ [], n < # al, stepf(sl[n], al[n], sl[n + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]), ¬ ( # ⌜sl from n + 1⌝ = # ⌜al from n + 1⌝ + ⌜1⌝ ∧ (∀ n0. ⌜n0⌝ < # ⌜al from n + 1⌝ → stepf(⌜sl from n + 1⌝ [n0], ⌜al from n + 1⌝ [n0], ⌜sl from n + 1⌝ [n0 +1]))) ∨ sl.last ≠ (sl from n + 1).last ⊦ |
# al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], n < # al, stepf(sl[n], al[n], sl[n + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]), # al ≠ n + (# sl - n + 1) ∨ ¬(n0 + n + 1 < # al → stepf((sl from n + 1)[n0], al[(n + 1) + n0], (sl from n + 1)[n0 + 1])) ∨ sl.last ≠ (sl from n + 1).last ⊦
Used simplifier rules: ⊦ ⌜x⌝ [n] = x[n]; (s) ⊦ m +1 = m + 1; (s) m + m0 < # x ⊦ (x from m)[m0] = x[m + m0]; (s) ⊦ m < n → (n ≤ m ↔ false); (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ ⌜x⌝ [n] = x[n]; (s) n0 ≤ n ⊦ m < n - n0 ↔ m + n0 < n; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m + 1 ≤ n ↔ m < n; (s) ⊦ ⌜m⌝ < ⌜n⌝ ↔ m < n; (s) ¬ # x < n ⊦ #(x from n) = # x - n; (s) ⊦ m < n + 1 ↔ ¬ n < m; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (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 + n = m + n0 ↔ n = n0; (s) n ≤ m ⊦ (m - n) + n0 = n1 ↔ m + n0 = n + n1; (s) ⊦ ⌜n⌝ + ⌜m⌝ = ⌜n0⌝ ↔ n + m = n0; (s) ¬ # x < n ⊦ #(x from n) = # x - n; (s) ⊦ m = m0 + n0 ∧ n < n0 → ¬ m < m0 + n; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s)
| # al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], n < # al, stepf(sl[n], al[n], sl[n + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]), # al ≠ n + (# sl - n + 1) ∨ ¬(n0 + n + 1 < # al → stepf((sl from n + 1)[n0], al[(n + 1) + n0], (sl from n + 1)[n0 + 1])) ∨ sl.last ≠ (sl from n + 1).last ⊦ |
# al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], # al ≠ n + (# sl - n + 1), al[n] ≠ τ, al ≠ [], n < # al, stepf(sl[n], al[n], sl[n + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦
# al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], al[n] ≠ τ, al ≠ [], n0 + n + 1 < # al, n < # al, stepf(sl[n], al[n], sl[n + 1]), ¬ stepf((sl from n + 1)[n0], al[(n + 1) + n0], (sl from n + 1)[n0 + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦
# al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], sl.last ≠ (sl from n + 1).last, al[n] ≠ τ, al ≠ [], n < # al, stepf(sl[n], al[n], sl[n + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦
| # al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], # al ≠ n + (# sl - n + 1), al[n] ≠ τ, al ≠ [], n < # al, stepf(sl[n], al[n], sl[n + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ |
Used simplifier rules: ⊦ m + 1 ≤ n ↔ m < n; (s) eqs: ⊦ m = n + n0 ∧ m = n + n1 → n0 = n1; (forward) from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic ⊦ m < n ↔ ¬ n ≤ m; (ss) fle-01: ⊦ m ≤ n ∧ n < n0 → m < n0; (forward) from specification nat lf-02: ⊦ m < n ∧ m = n0 → n0 < n; (forward) from specification nat-basic ⊦ ¬ m + n < m; (s) n ≤ m ⊦ n0 = m - n ↔ m = n0 + n; (elim) Used terms: # sl, n + 1, n1
| # al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], al[n] ≠ τ, al ≠ [], n0 + n + 1 < # al, n < # al, stepf(sl[n], al[n], sl[n + 1]), ¬ stepf((sl from n + 1)[n0], al[(n + 1) + n0], (sl from n + 1)[n0 + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ |
# al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], n < # al, n0 + n + 1 < # al, stepf(sl[n], al[n], sl[n + 1]), ¬ stepf((sl from n + 1)[n0], al[(n + 1) + n0], (sl from n + 1)[n0 + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦
| # al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], n < # al, n0 + n + 1 < # al, stepf(sl[n], al[n], sl[n + 1]), ¬ stepf((sl from n + 1)[n0], al[(n + 1) + n0], (sl from n + 1)[n0 + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ |
m + m0 < # x ⊦ (x from m)[m0] = x[m + m0]
# al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], al[n] ≠ τ, al ≠ [], n0 + n + 1 < # al, n < # al, (n + 1) + n0 < # sl, stepf(sl[n], al[n], sl[n + 1]), ¬ stepf(sl[(n + 1) + n0], al[(n + 1) + n0], (sl from n + 1)[n0 + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦
Used simplifier rules: ⊦ m < n ↔ ¬ n ≤ m; (ss) fle-01: ⊦ m ≤ n ∧ n < n0 → m < n0; (forward) from specification nat lf-02: ⊦ m < n ∧ m = n0 → n0 < n; (forward) from specification nat-basic ⊦ ¬ m + n < m; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic Used terms: n0, n + 1, sl
| m + m0 < # x ⊦ (x from m)[m0] = x[m + m0] |
| # al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], al[n] ≠ τ, al ≠ [], n0 + n + 1 < # al, n < # al, (n + 1) + n0 < # sl, stepf(sl[n], al[n], sl[n + 1]), ¬ stepf(sl[(n + 1) + n0], al[(n + 1) + n0], (sl from n + 1)[n0 + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ |
# al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], al[n] ≠ τ, al ≠ [], sl ≠ [], n0 + n + 1 < # al, n < # al, (n + 1) + n0 < # sl, stepf(sl[n], al[n], sl[n + 1]), ¬ stepf(sl[(n + 1) + n0], al[(n + 1) + n0], (sl from n + 1)[n0 + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦
Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m + n < m0 → m + n < m0 + n0; (s) ⊦ # x = 0 ↔ x = []; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic
| # al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], al[n] ≠ τ, al ≠ [], sl ≠ [], n0 + n + 1 < # al, n < # al, (n + 1) + n0 < # sl, stepf(sl[n], al[n], sl[n + 1]), ¬ stepf(sl[(n + 1) + n0], al[(n + 1) + n0], (sl from n + 1)[n0 + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ |
m + m0 < # x ⊦ (x from m)[m0] = x[m + m0]
# al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], sl ≠ [], (n + 1) + n0 < # sl, n < # al, n0 + n + 1 < # al, stepf(sl[n], al[n], sl[n + 1]), ¬ (n + 1) + n0 + 1 < # sl, ¬ stepf(sl[(n + 1) + n0], al[(n + 1) + n0], (sl from n + 1)[n0 + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦
# al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], sl ≠ [], (n + 1) + n0 < # sl, n < # al, n0 + n + 1 < # al, (n + 1) + n0 + 1 < # sl, stepf(sl[n], al[n], sl[n + 1]), ¬ stepf(sl[(n + 1) + n0], al[(n + 1) + n0], sl[(n + 1) + n0 + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦
Used terms: n0 + 1, n + 1, sl
| m + m0 < # x ⊦ (x from m)[m0] = x[m + m0] |
| # al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], sl ≠ [], (n + 1) + n0 < # sl, n < # al, n0 + n + 1 < # al, stepf(sl[n], al[n], sl[n + 1]), ¬ (n + 1) + n0 + 1 < # sl, ¬ stepf(sl[(n + 1) + n0], al[(n + 1) + n0], (sl from n + 1)[n0 + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ |
# al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], sl ≠ [], (n + 1) + n0 < # sl, n < # al, n0 + n + 1 < # al, stepf(sl[n], al[n], sl[n + 1]), # sl ≤ 2 + n + n0, ¬ stepf(sl[(n + 1) + n0], al[(n + 1) + n0], (sl from n + 1)[n0 + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦
Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m + n < m + n0 ↔ n < n0; (s) fle: ⊦ m < n ∧ n ≤ n0 → m < n0; (forward) from specification nat ⊦ m < n ↔ ¬ n ≤ m; (ss)
| # al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], sl ≠ [], (n + 1) + n0 < # sl, n < # al, n0 + n + 1 < # al, stepf(sl[n], al[n], sl[n + 1]), # sl ≤ 2 + n + n0, ¬ stepf(sl[(n + 1) + n0], al[(n + 1) + n0], (sl from n + 1)[n0 + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ |
# al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], al[n] ≠ τ, al ≠ [], sl ≠ [], n0 + n + 1 < # al, n < # al, (n + 1) + n0 < # sl, stepf(sl[n], al[n], sl[n + 1]), # sl ≤ 2 + n + n0, ¬ stepf(sl[(n + 1) + n0], al[(n + 1) + n0], (sl from n + 1)[n0 + 1]), n0 + n + 1 < # al → stepf(sl[n0 + n + 1], al[n0 + n + 1], sl[(n0 + n + 1) + 1]) ⊦
Used terms: n0 + n + 1
| # al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], al[n] ≠ τ, al ≠ [], sl ≠ [], n0 + n + 1 < # al, n < # al, (n + 1) + n0 < # sl, stepf(sl[n], al[n], sl[n + 1]), # sl ≤ 2 + n + n0, ¬ stepf(sl[(n + 1) + n0], al[(n + 1) + n0], (sl from n + 1)[n0 + 1]), n0 + n + 1 < # al → stepf(sl[n0 + n + 1], al[n0 + n + 1], sl[(n0 + n + 1) + 1]) ⊦ |
# al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], sl ≠ [], (n + 1) + n0 < # sl, n < # al, n0 + n + 1 < # al, stepf(sl[n], al[n], sl[n + 1]), stepf(sl[n0 + n + 1], al[n0 + n + 1], sl[2 + n0 + n]), # sl ≤ 2 + n + n0, ¬ stepf(sl[(n + 1) + n0], al[(n + 1) + n0], (sl from n + 1)[n0 + 1]) ⊦
Used simplifier rules: a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic
| # al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], sl ≠ [], (n + 1) + n0 < # sl, n < # al, n0 + n + 1 < # al, stepf(sl[n], al[n], sl[n + 1]), stepf(sl[n0 + n + 1], al[n0 + n + 1], sl[2 + n0 + n]), # sl ≤ 2 + n + n0, ¬ stepf(sl[(n + 1) + n0], al[(n + 1) + n0], (sl from n + 1)[n0 + 1]) ⊦ |
m + m0 < # x ⊦ (x from m)[m0] = x[m + m0]
# al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], al[n] ≠ τ, al ≠ [], sl ≠ [], n0 + n + 1 < # al, n < # al, (n + 1) + n0 < # sl, stepf(sl[n0 + n + 1], al[n0 + n + 1], sl[2 + n0 + n]), stepf(sl[n], al[n], sl[n + 1]), # sl ≤ 2 + n + n0, ¬ (n + 1) + n0 + 1 < # sl, ¬ stepf(sl[(n + 1) + n0], al[(n + 1) + n0], (sl from n + 1)[n0 + 1]) ⊦
Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m ≤ n → (n < m ↔ false); (s) Used terms: sl, n + 1, n0 + 1
| m + m0 < # x ⊦ (x from m)[m0] = x[m + m0] |
| # al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], al[n] ≠ τ, al ≠ [], sl ≠ [], n0 + n + 1 < # al, n < # al, (n + 1) + n0 < # sl, stepf(sl[n0 + n + 1], al[n0 + n + 1], sl[2 + n0 + n]), stepf(sl[n], al[n], sl[n + 1]), # sl ≤ 2 + n + n0, ¬ (n + 1) + n0 + 1 < # sl, ¬ stepf(sl[(n + 1) + n0], al[(n + 1) + n0], (sl from n + 1)[n0 + 1]) ⊦ |
# al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], sl ≠ [], (n + 1) + n0 < # sl, n < # al, n0 + n + 1 < # al, stepf(sl[n], al[n], sl[n + 1]), stepf(sl[n0 + n + 1], al[n0 + n + 1], sl[2 + n0 + n]), # sl ≤ 2 + n + n0, ¬ stepf(sl[(n + 1) + n0], al[(n + 1) + n0], (sl from n + 1)[n0 + 1]) ⊦
Used simplifier rules: ⊦ m ≤ n → (n < m ↔ false); (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic
| # al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], sl ≠ [], (n + 1) + n0 < # sl, n < # al, n0 + n + 1 < # al, stepf(sl[n], al[n], sl[n + 1]), stepf(sl[n0 + n + 1], al[n0 + n + 1], sl[2 + n0 + n]), # sl ≤ 2 + n + n0, ¬ stepf(sl[(n + 1) + n0], al[(n + 1) + n0], (sl from n + 1)[n0 + 1]) ⊦ |
Used simplifier rules: n < n0 ⊦ m + (* n) ≤ m0 + (* n0) ↔ m ≤ m0 + (n0 - n); (s) ⊦ m < n → (n ≤ m ↔ false); (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic
| # al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], sl ≠ [], (n + 1) + n0 < # sl, n < # al, n0 + n + 1 < # al, (n + 1) + n0 + 1 < # sl, stepf(sl[n], al[n], sl[n + 1]), ¬ stepf(sl[(n + 1) + n0], al[(n + 1) + n0], sl[(n + 1) + n0 + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ |
# al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], sl ≠ [], 2 + n + n0 < # sl, (n + 1) + n0 < # sl, n < # al, n0 + n + 1 < # al, (n + n0) + 1 < # al, stepf(sl[n], al[n], sl[n + 1]), ¬ stepf(sl[(n + 1) + n0], al[(n + 1) + n0], sl[2 + n + n0]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦
Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic n0 < n ⊦ m + (* n) < m0 + (* n0) ↔ m + (n - n0) < m0; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic
| # al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, al ≠ [], sl ≠ [], 2 + n + n0 < # sl, (n + 1) + n0 < # sl, n < # al, n0 + n + 1 < # al, (n + n0) + 1 < # al, stepf(sl[n], al[n], sl[n + 1]), ¬ stepf(sl[(n + 1) + n0], al[(n + 1) + n0], sl[2 + n + n0]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ |
Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic Used terms: (n + n0) + 1
| # al + 1 = # sl, ⌜al to n⌝ ^ = [], ⌜al from n + 1⌝ ^ = [], sl.last ≠ (sl from n + 1).last, al[n] ≠ τ, al ≠ [], n < # al, stepf(sl[n], al[n], sl[n + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ |
# al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], sl = sl0 + a ', al[n] ≠ τ, a ≠ (sl from n + 1).last, al ≠ [], sl ≠ [], n < # al, stepf(sl[n], al[n], sl[n + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦
Used simplifier rules: ⊦ # [] = 0; (s) ⊦ m + n = 0 ↔ m = 0 ∧ n = 0; (ws) ⊦ # x = 0 ↔ x = []; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic x ≠ [] ⊦ a = x.last ∧ y = x.butlast ↔ x = y + a '; (elim) Used terms: sl, a, y
| # al + 1 = # sl, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], sl = sl0 + a ', al[n] ≠ τ, a ≠ (sl from n + 1).last, al ≠ [], sl ≠ [], n < # al, stepf(sl[n], al[n], sl[n + 1]), ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ |
# al = # sl0, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, a ≠ (sl0 + a ' from n + 1).last, al ≠ [], sl0 ≠ [], n < # sl0, stepf(sl0[n], al[n], (sl0 + a ')[n + 1]), ∀ n0. n0 < # sl0 → stepf(sl0[n0], al[n0], (sl0 + a ')[n0 + 1]) ⊦
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ n < # x → (x + a ')[n] = x[n]; (s) ⊦ # x = 0 ↔ x = []; (s) lf-01: ⊦ m < n ∧ n = n0 → m < n0; (forward) from specification nat-basic f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic ⊦ x + a ' ≠ []; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ m + n = m + n0 ↔ n = n0; (s) ⊦ # a ' = 0 +1; (s) ⊦ #(x + y) = # x + # y; (s)
| # al = # sl0, ⌜al from n + 1⌝ ^ = [], ⌜al to n⌝ ^ = [], al[n] ≠ τ, a ≠ (sl0 + a ' from n + 1).last, al ≠ [], sl0 ≠ [], n < # sl0, stepf(sl0[n], al[n], (sl0 + a ')[n + 1]), ∀ n0. n0 < # sl0 → stepf(sl0[n0], al[n0], (sl0 + a ')[n0 + 1]) ⊦ |
⊦ n ≤ # x → x + y from n = (x from n) + y
Used simplifier rules: ⊦ (x + a ').last = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ m + 1 ≤ n ↔ m < n; (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ m < n → (n ≤ m ↔ false); (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic Used terms: n + 1, a ', sl0
| ⊦ n ≤ # x → x + y from n = (x from n) + y |
| # al + 1 = # sl, ⌜al⌝ ^ = ⌜a '⌝ , al[n] ≠ τ, a ≠ τ, al ≠ (al to n + 1) + (al from n + 1), al ≠ [], n < # al, ∀ n0. n0 < # al → stepf(sl[n0], al[n0], sl[n0 + 1]) ⊦ move(IOAut(startf, stepf))(sl[0], [], sl[n]) ∧ stepf(sl[n], a, sl[n + 1]) ∧ move(IOAut(startf, stepf))(sl[n + 1], [], sl.last) |
⊦ n ≤ # x → (x to n) + (x from n) = x
Used simplifier rules: ⊦ m + 1 ≤ n ↔ m < n; (s) ⊦ m < n ↔ ¬ n ≤ m; (ss) ⊦ m < n → (n ≤ m ↔ false); (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic Used terms: n + 1, al
| ⊦ n ≤ # x → (x to n) + (x from n) = x |
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.