| frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ) ⊦ ∃ sl0, al0. hd(sl0) = hd(sl) ∧ sl0.last = sl.last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al1. hd(sl1) = hd(sl) ∧ sl1.last = sl.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al1⌝ ) → # sl0 ≤ # sl1) |
frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), ∀ sl0, startf, stepf, al. # sl0 < # sl → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = hd(sl) ∧ sl0.last = sl.last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al1. hd(sl1) = hd(sl) ∧ sl1.last = sl.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al1⌝ ) → # sl0 ≤ # sl1)
Used simplifier rules: <; (wellfounded) Used terms: # sl
| frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), ∀ sl0, startf, stepf, al. # sl0 < # sl → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = hd(sl) ∧ sl0.last = sl.last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al1. hd(sl1) = hd(sl) ∧ sl1.last = sl.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al1⌝ ) → # sl0 ≤ # sl1) |
frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), ∀ sl0, startf, stepf, al. # sl0 < # sl → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = hd(sl) ∧ sl0.last = sl.last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al1. hd(sl1) = hd(sl) ∧ sl1.last = sl.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al1⌝ ) → # sl0 ≤ # sl1)
| frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), ∀ sl0, startf, stepf, al. # sl0 < # sl → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = hd(sl) ∧ sl0.last = sl.last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al1. hd(sl1) = hd(sl) ∧ sl1.last = sl.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al1⌝ ) → # sl0 ≤ # sl1) |
sl = a + sl3, sl ≠ [], frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), ∀ sl0, startf, stepf, al. # sl0 < # sl → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = a ∧ sl0.last = sl.last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al1. hd(sl1) = a ∧ sl1.last = sl.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al1⌝ ) → # sl0 ≤ # sl1)
Used simplifier rules: not-frag-empty: ⊦ ¬ frag(IOAut(startf, stepf))([], α); ⊦ ⌜[]⌝ = []; (s) x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y; (elim) Used terms: sl, a, y
| sl = a + sl3, sl ≠ [], frag(IOAut(startf, stepf))(⌜sl⌝ , ⌜al⌝ ), ∀ sl0, startf, stepf, al. # sl0 < # sl → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = a ∧ sl0.last = sl.last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al1. hd(sl1) = a ∧ sl1.last = sl.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al1⌝ ) → # sl0 ≤ # sl1) |
frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = a ∧ sl0.last = (hd(sl0) ' + sl3).last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al1. hd(sl1) = hd(sl0) ∧ sl1.last = (hd(sl0) ' + sl3).last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al1⌝ ) → # sl0 ≤ # sl1)
Used simplifier rules: ⊦ a + x = a ' + x; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ a ' + x ≠ []; (s)
| frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = a ∧ sl0.last = (hd(sl0) ' + sl3).last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al1. hd(sl1) = hd(sl0) ∧ sl1.last = (hd(sl0) ' + sl3).last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al1⌝ ) → # sl0 ≤ # sl1) |
frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = a ∧ sl0.last = (hd(sl0) ' + sl3).last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al1. hd(sl1) = hd(sl0) ∧ sl1.last = (hd(sl0) ' + sl3).last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al1⌝ ) → # sl0 ≤ # sl1), hd(a ' + sl3) = a ∧ (a ' + sl3).last = (hd(a ' + sl3) ' + sl3).last ∧ frag(IOAut(startf, stepf))(⌜a ' + sl3⌝ , ⌜al⌝ ) ∧ (∀ sl1, al1. hd(sl1) = hd(a ' + sl3) ∧ sl1.last = (hd(a ' + sl3) ' + sl3).last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al1⌝ ) → #(a ' + sl3) ≤ # sl1)
Used terms: a ' + sl3, al
| frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = a ∧ sl0.last = (hd(sl0) ' + sl3).last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al1. hd(sl1) = hd(sl0) ∧ sl1.last = (hd(sl0) ' + sl3).last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al1⌝ ) → # sl0 ≤ # sl1), hd(a ' + sl3) = a ∧ (a ' + sl3).last = (hd(a ' + sl3) ' + sl3).last ∧ frag(IOAut(startf, stepf))(⌜a ' + sl3⌝ , ⌜al⌝ ) ∧ (∀ sl1, al1. hd(sl1) = hd(a ' + sl3) ∧ sl1.last = (hd(a ' + sl3) ' + sl3).last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al1⌝ ) → #(a ' + sl3) ≤ # sl1) |
sl1.last = (hd(sl1) ' + sl3).last, frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜hd(sl1) '⌝ + ⌜sl3⌝ , ⌜al⌝ ), # sl1 ≤ # sl3, ∀ sl0, startf, stepf, al. # sl0 < #(hd(sl1) + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = hd(sl1) ∧ sl0.last = (hd(sl0) ' + sl3).last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al1. hd(sl1) = hd(sl0) ∧ sl1.last = (hd(sl0) ' + sl3).last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al1⌝ ) → # sl0 ≤ # sl1)
Used simplifier rules: ⊦ m < n ↔ ¬ n ≤ m; (ss) 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) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ m +1 = m + 1; (s) ⊦ #(a ' + x) = (# x)+1; (s) ⊦ hd(a ' + x) = a; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s)
| sl1.last = (hd(sl1) ' + sl3).last, frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜hd(sl1) '⌝ + ⌜sl3⌝ , ⌜al⌝ ), # sl1 ≤ # sl3, ∀ sl0, startf, stepf, al. # sl0 < #(hd(sl1) + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = hd(sl1) ∧ sl0.last = (hd(sl0) ' + sl3).last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al1. hd(sl1) = hd(sl0) ∧ sl1.last = (hd(sl0) ' + sl3).last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al1⌝ ) → # sl0 ≤ # sl1) |
sl1.last = (a ' + sl3).last, sl1 = a + sl, sl1 ≠ [], frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al1⌝ ), # sl1 ≤ # sl3, ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = a ∧ sl0.last = (hd(sl0) ' + sl3).last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al1. hd(sl1) = hd(sl0) ∧ sl1.last = (hd(sl0) ' + sl3).last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al1⌝ ) → # sl0 ≤ # sl1)
Used simplifier rules: not-frag-empty: ⊦ ¬ frag(IOAut(startf, stepf))([], α); ⊦ # [] = 0; (s) ⊦ 0 ≤ m; (s) ⊦ ⌜[]⌝ = []; (s) x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y; (elim) Used terms: sl1, a, y
| sl1.last = (a ' + sl3).last, sl1 = a + sl, sl1 ≠ [], frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al1⌝ ), # sl1 ≤ # sl3, ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = a ∧ sl0.last = (hd(sl0) ' + sl3).last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al1. hd(sl1) = hd(sl0) ∧ sl1.last = (hd(sl0) ' + sl3).last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al1⌝ ) → # sl0 ≤ # sl1) |
(a ' + sl).last = sl3.last, sl3 ≠ [], # sl < # sl3, frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = a ∧ sl0.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al2. hd(sl1) = hd(sl0) ∧ sl1.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al2⌝ ) → # sl0 ≤ # sl1)
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ x ≠ [] → (a ' + x).last = x.last; (s) ⊦ # x = 0 ↔ x = []; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ a + x = a ' + x; (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 +1 = m + 1; (s) ⊦ #(a ' + x) = (# x)+1; (s) ⊦ a ' + x ≠ []; (s)
| (a ' + sl).last = sl3.last, sl3 ≠ [], # sl < # sl3, frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = a ∧ sl0.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al2. hd(sl1) = hd(sl0) ∧ sl1.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al2⌝ ) → # sl0 ≤ # sl1) |
(a ' + sl).last = sl3.last, sl = [], sl3 ≠ [], # sl < # sl3, frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl⌝ , ⌜al1⌝ ), ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = a ∧ sl0.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al2. hd(sl1) = hd(sl0) ∧ sl1.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al2⌝ ) → # sl0 ≤ # sl1)
(a ' + sl).last = sl3.last, sl ≠ [], sl3 ≠ [], # sl < # sl3, frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl⌝ , ⌜al1⌝ ), ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = a ∧ sl0.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al2. hd(sl1) = hd(sl0) ∧ sl1.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al2⌝ ) → # sl0 ≤ # sl1)
Used formulas: sl = []
| (a ' + sl).last = sl3.last, sl = [], sl3 ≠ [], # sl < # sl3, frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl⌝ , ⌜al1⌝ ), ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = a ∧ sl0.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al2. hd(sl1) = hd(sl0) ∧ sl1.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al2⌝ ) → # sl0 ≤ # sl1) |
sl3 ≠ [], frag(IOAut(startf, stepf))(⌜sl3.last '⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜sl3.last '⌝ + ⌜sl3⌝ , ⌜al⌝ ), ∀ sl0, startf, stepf, al. # sl0 < #(sl3.last + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = sl3.last ∧ sl0.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al2. hd(sl1) = hd(sl0) ∧ sl1.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al2⌝ ) → # sl0 ≤ # sl1)
Used simplifier rules: ⊦ # x = 0 ↔ x = []; (s) ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ # [] = 0; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[IOstatestream] ⊦ σ + [] = σ; (s) ⊦ ⌜[]⌝ = []; (s) ⊦ a '.last = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ x + [] = x; (s)
| sl3 ≠ [], frag(IOAut(startf, stepf))(⌜sl3.last '⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜sl3.last '⌝ + ⌜sl3⌝ , ⌜al⌝ ), ∀ sl0, startf, stepf, al. # sl0 < #(sl3.last + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = sl3.last ∧ sl0.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al2. hd(sl1) = hd(sl0) ∧ sl1.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al2⌝ ) → # sl0 ≤ # sl1) |
Used simplifier rules: not-frag-empty: ⊦ ¬ frag(IOAut(startf, stepf))([], α); ⊦ a '.last = a; (s) ⊦ hd(a ') = a; (s) ⊦ # a ' = 0 +1; (s) ⊦ m ≤ n ↔ ¬ n < m; (ss) ⊦ m < 1 ↔ m = 0; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ ⌜[]⌝ = []; (s) Used terms: sl3.last ', al1
| (a ' + sl).last = sl3.last, sl ≠ [], sl3 ≠ [], # sl < # sl3, frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl⌝ , ⌜al1⌝ ), ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = a ∧ sl0.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al2. hd(sl1) = hd(sl0) ∧ sl1.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al2⌝ ) → # sl0 ≤ # sl1) |
sl.last = sl3.last, sl ≠ [], sl3 ≠ [], # sl < # sl3, frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = a ∧ sl0.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al2. hd(sl1) = hd(sl0) ∧ sl1.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al2⌝ ) → # sl0 ≤ # sl1)
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ x ≠ [] → (a ' + x).last = x.last; (s)
| sl.last = sl3.last, sl ≠ [], sl3 ≠ [], # sl < # sl3, frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = a ∧ sl0.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al2. hd(sl1) = hd(sl0) ∧ sl1.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al2⌝ ) → # sl0 ≤ # sl1) |
sl.last = sl3.last, sl ≠ [], sl3 ≠ [], # sl < # sl3, frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl⌝ , ⌜al1⌝ ), ∃ sl1, al0. hd(sl1) = hd(a ' + sl) ∧ sl1.last = (a ' + sl).last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(a ' + sl) ∧ sl2.last = (a ' + sl).last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2), ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = a ∧ sl0.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al2. hd(sl1) = hd(sl0) ∧ sl1.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al2⌝ ) → # sl0 ≤ # sl1)
Used simplifier rules: ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ a + x = a ' + x; (s) ⊦ #(a ' + x) = (# x)+1; (s) ⊦ m +1 = m + 1; (s) ⊦ m + n < m + n0 ↔ n < n0; (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: a ' + sl, startf, stepf, al1
| sl.last = sl3.last, sl ≠ [], sl3 ≠ [], # sl < # sl3, frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl⌝ , ⌜al1⌝ ), ∃ sl1, al0. hd(sl1) = hd(a ' + sl) ∧ sl1.last = (a ' + sl).last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(a ' + sl) ∧ sl2.last = (a ' + sl).last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2), ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = a ∧ sl0.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al2. hd(sl1) = hd(sl0) ∧ sl1.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al2⌝ ) → # sl0 ≤ # sl1) |
sl1.last = sl3.last, sl.last = sl3.last, sl ≠ [], sl3 ≠ [], # sl < # sl3, frag(IOAut(startf, stepf))(⌜hd(sl1) '⌝ + ⌜sl3⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜hd(sl1) '⌝ + ⌜sl⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ), ∀ sl2, al2. hd(sl2) = hd(sl1) ∧ sl2.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al2⌝ ) → # sl1 ≤ # sl2, ∀ sl0, startf, stepf, al. # sl0 < #(hd(sl1) + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = hd(sl1) ∧ sl0.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al2. hd(sl1) = hd(sl0) ∧ sl1.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al2⌝ ) → # sl0 ≤ # sl1)
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ x ≠ [] → (a ' + x).last = x.last; (s) ⊦ hd(a ' + x) = a; (s)
| sl1.last = sl3.last, sl.last = sl3.last, sl ≠ [], sl3 ≠ [], # sl < # sl3, frag(IOAut(startf, stepf))(⌜hd(sl1) '⌝ + ⌜sl3⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜hd(sl1) '⌝ + ⌜sl⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ), ∀ sl2, al2. hd(sl2) = hd(sl1) ∧ sl2.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al2⌝ ) → # sl1 ≤ # sl2, ∀ sl0, startf, stepf, al. # sl0 < #(hd(sl1) + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = hd(sl1) ∧ sl0.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al2. hd(sl1) = hd(sl0) ∧ sl1.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al2⌝ ) → # sl0 ≤ # sl1) |
sl.last = sl3.last, sl1.last = sl3.last, sl1 = a + sl4, sl ≠ [], sl1 ≠ [], sl3 ≠ [], # sl < # sl3, frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), ∀ sl2, al2. hd(sl2) = a ∧ sl2.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al2⌝ ) → # sl1 ≤ # sl2, ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = a ∧ sl0.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al2. hd(sl1) = hd(sl0) ∧ sl1.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al2⌝ ) → # sl0 ≤ # sl1)
Used simplifier rules: not-frag-empty: ⊦ ¬ frag(IOAut(startf, stepf))([], α); ⊦ ⌜[]⌝ = []; (s) x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y; (elim) Used terms: sl1, a, y
| sl.last = sl3.last, sl1.last = sl3.last, sl1 = a + sl4, sl ≠ [], sl1 ≠ [], sl3 ≠ [], # sl < # sl3, frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), ∀ sl2, al2. hd(sl2) = a ∧ sl2.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al2⌝ ) → # sl1 ≤ # sl2, ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = a ∧ sl0.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al2. hd(sl1) = hd(sl0) ∧ sl1.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al2⌝ ) → # sl0 ≤ # sl1) |
sl.last = sl3.last, (a ' + sl4).last = sl3.last, sl ≠ [], sl3 ≠ [], # sl < # sl3, frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl4⌝ , ⌜al0⌝ ), ∀ sl2, al2. hd(sl2) = a ∧ sl2.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al2⌝ ) → # sl4 < # sl2, ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = a ∧ sl0.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al2. hd(sl1) = hd(sl0) ∧ sl1.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al2⌝ ) → # sl0 ≤ # sl1)
Used simplifier rules: 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) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ m +1 = m + 1; (s) ⊦ #(a ' + x) = (# x)+1; (s) ⊦ a + x = a ' + x; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ a ' + x ≠ []; (s)
| sl.last = sl3.last, (a ' + sl4).last = sl3.last, sl ≠ [], sl3 ≠ [], # sl < # sl3, frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl4⌝ , ⌜al0⌝ ), ∀ sl2, al2. hd(sl2) = a ∧ sl2.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al2⌝ ) → # sl4 < # sl2, ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = a ∧ sl0.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al2. hd(sl1) = hd(sl0) ∧ sl1.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al2⌝ ) → # sl0 ≤ # sl1) |
(a ' + sl4).last = sl3.last, sl.last = sl3.last, sl4 = [], sl ≠ [], sl3 ≠ [], # sl < # sl3, frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl4⌝ , ⌜al0⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), ∀ sl2, al2. hd(sl2) = a ∧ sl2.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al2⌝ ) → # sl4 < # sl2, ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = a ∧ sl0.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al2. hd(sl1) = hd(sl0) ∧ sl1.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al2⌝ ) → # sl0 ≤ # sl1)
(a ' + sl4).last = sl3.last, sl.last = sl3.last, sl ≠ [], sl3 ≠ [], sl4 ≠ [], # sl < # sl3, frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl4⌝ , ⌜al0⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), ∀ sl2, al2. hd(sl2) = a ∧ sl2.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al2⌝ ) → # sl4 < # sl2, ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = a ∧ sl0.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al2. hd(sl1) = hd(sl0) ∧ sl1.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al2⌝ ) → # sl0 ≤ # sl1)
Used formulas: sl4 = []
| (a ' + sl4).last = sl3.last, sl.last = sl3.last, sl4 = [], sl ≠ [], sl3 ≠ [], # sl < # sl3, frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl4⌝ , ⌜al0⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), ∀ sl2, al2. hd(sl2) = a ∧ sl2.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al2⌝ ) → # sl4 < # sl2, ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = a ∧ sl0.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al2. hd(sl1) = hd(sl0) ∧ sl1.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al2⌝ ) → # sl0 ≤ # sl1) |
sl.last = sl3.last, sl ≠ [], sl3 ≠ [], # sl < # sl3, frag(IOAut(startf, stepf))(⌜sl3.last '⌝ , ⌜al0⌝ ), frag(IOAut(startf, stepf))(⌜sl3.last '⌝ + ⌜sl⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜sl3.last '⌝ + ⌜sl3⌝ , ⌜al⌝ ), ∀ sl0, startf, stepf, al. # sl0 < #(sl3.last + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = sl3.last ∧ sl0.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al2. hd(sl1) = hd(sl0) ∧ sl1.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al2⌝ ) → # sl0 ≤ # sl1)
Used simplifier rules: not-frag-empty: ⊦ ¬ frag(IOAut(startf, stepf))([], α); ⊦ ⌜[]⌝ = []; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ # [] = 0; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[IOstatestream] ⊦ σ + [] = σ; (s) ⊦ a '.last = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ x + [] = x; (s)
| sl.last = sl3.last, sl ≠ [], sl3 ≠ [], # sl < # sl3, frag(IOAut(startf, stepf))(⌜sl3.last '⌝ , ⌜al0⌝ ), frag(IOAut(startf, stepf))(⌜sl3.last '⌝ + ⌜sl⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜sl3.last '⌝ + ⌜sl3⌝ , ⌜al⌝ ), ∀ sl0, startf, stepf, al. # sl0 < #(sl3.last + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = sl3.last ∧ sl0.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al2. hd(sl1) = hd(sl0) ∧ sl1.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al2⌝ ) → # sl0 ≤ # sl1) |
Used simplifier rules: not-frag-empty: ⊦ ¬ frag(IOAut(startf, stepf))([], α); ⊦ a '.last = a; (s) ⊦ hd(a ') = a; (s) ⊦ # a ' = 0 +1; (s) ⊦ m ≤ n ↔ ¬ n < m; (ss) ⊦ m < 1 ↔ m = 0; (s) ⊦ # x = 0 ↔ x = []; (s) ⊦ ⌜[]⌝ = []; (s) Used terms: sl3.last ', al0
| (a ' + sl4).last = sl3.last, sl.last = sl3.last, sl ≠ [], sl3 ≠ [], sl4 ≠ [], # sl < # sl3, frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl4⌝ , ⌜al0⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), ∀ sl2, al2. hd(sl2) = a ∧ sl2.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al2⌝ ) → # sl4 < # sl2, ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = a ∧ sl0.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al2. hd(sl1) = hd(sl0) ∧ sl1.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al2⌝ ) → # sl0 ≤ # sl1) |
sl.last = sl3.last, sl4.last = sl3.last, sl ≠ [], sl3 ≠ [], sl4 ≠ [], # sl < # sl3, frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl4⌝ , ⌜al0⌝ ), ∀ sl2, al2. hd(sl2) = a ∧ sl2.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al2⌝ ) → # sl4 < # sl2, ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = a ∧ sl0.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al2. hd(sl1) = hd(sl0) ∧ sl1.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al2⌝ ) → # sl0 ≤ # sl1)
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ x ≠ [] → (a ' + x).last = x.last; (s)
| sl.last = sl3.last, sl4.last = sl3.last, sl ≠ [], sl3 ≠ [], sl4 ≠ [], # sl < # sl3, frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl4⌝ , ⌜al0⌝ ), ∀ sl2, al2. hd(sl2) = a ∧ sl2.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al2⌝ ) → # sl4 < # sl2, ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ ∃ sl0, al0. hd(sl0) = a ∧ sl0.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al2. hd(sl1) = hd(sl0) ∧ sl1.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al2⌝ ) → # sl0 ≤ # sl1) |
sl4.last = sl3.last, sl.last = sl3.last, sl ≠ [], sl3 ≠ [], sl4 ≠ [], # sl < # sl3, frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl4⌝ , ⌜al0⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), ∀ sl2, al2. hd(sl2) = a ∧ sl2.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al2⌝ ) → # sl4 < # sl2, ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ hd(a ' + sl4) = a ∧ (a ' + sl4).last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜a ' + sl4⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al2. hd(sl1) = hd(a ' + sl4) ∧ sl1.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al2⌝ ) → #(a ' + sl4) ≤ # sl1)
Used terms: a ' + sl4, al0
| sl4.last = sl3.last, sl.last = sl3.last, sl ≠ [], sl3 ≠ [], sl4 ≠ [], # sl < # sl3, frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl4⌝ , ⌜al0⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), ∀ sl2, al2. hd(sl2) = a ∧ sl2.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al2⌝ ) → # sl4 < # sl2, ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ hd(a ' + sl4) = a ∧ (a ' + sl4).last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜a ' + sl4⌝ , ⌜al0⌝ ) ∧ (∀ sl1, al2. hd(sl1) = hd(a ' + sl4) ∧ sl1.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al2⌝ ) → #(a ' + sl4) ≤ # sl1) |
sl1.last = sl3.last, sl4.last = sl3.last, sl.last = sl3.last, sl ≠ [], sl3 ≠ [], sl4 ≠ [], # sl < # sl3, frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al2⌝ ), frag(IOAut(startf, stepf))(⌜hd(sl1) '⌝ + ⌜sl4⌝ , ⌜al0⌝ ), frag(IOAut(startf, stepf))(⌜hd(sl1) '⌝ + ⌜sl⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜hd(sl1) '⌝ + ⌜sl3⌝ , ⌜al⌝ ), # sl1 ≤ # sl4, ∀ sl2, al2. hd(sl2) = hd(sl1) ∧ sl2.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al2⌝ ) → # sl4 < # sl2, ∀ sl0, startf, stepf, al. # sl0 < #(hd(sl1) + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦
Used simplifier rules: ⊦ m < n ↔ ¬ n ≤ m; (ss) 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) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ m +1 = m + 1; (s) ⊦ #(a ' + x) = (# x)+1; (s) ⊦ hd(a ' + x) = a; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ x ≠ [] → (a ' + x).last = x.last; (s)
| sl1.last = sl3.last, sl4.last = sl3.last, sl.last = sl3.last, sl ≠ [], sl3 ≠ [], sl4 ≠ [], # sl < # sl3, frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al2⌝ ), frag(IOAut(startf, stepf))(⌜hd(sl1) '⌝ + ⌜sl4⌝ , ⌜al0⌝ ), frag(IOAut(startf, stepf))(⌜hd(sl1) '⌝ + ⌜sl⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜hd(sl1) '⌝ + ⌜sl3⌝ , ⌜al⌝ ), # sl1 ≤ # sl4, ∀ sl2, al2. hd(sl2) = hd(sl1) ∧ sl2.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al2⌝ ) → # sl4 < # sl2, ∀ sl0, startf, stepf, al. # sl0 < #(hd(sl1) + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ |
sl.last = sl3.last, sl4.last = sl3.last, sl1.last = sl3.last, sl1 = a + sl5, sl ≠ [], sl1 ≠ [], sl3 ≠ [], sl4 ≠ [], # sl < # sl3, frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl4⌝ , ⌜al0⌝ ), frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al2⌝ ), # sl1 ≤ # sl4, ∀ sl2, al2. hd(sl2) = a ∧ sl2.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al2⌝ ) → # sl4 < # sl2, ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦
Used simplifier rules: not-frag-empty: ⊦ ¬ frag(IOAut(startf, stepf))([], α); ⊦ # [] = 0; (s) ⊦ 0 ≤ m; (s) ⊦ ⌜[]⌝ = []; (s) x ≠ [] ⊦ a = hd(x) ∧ y = tl(x) ↔ x = a + y; (elim) Used terms: sl1, a, y
| sl.last = sl3.last, sl4.last = sl3.last, sl1.last = sl3.last, sl1 = a + sl5, sl ≠ [], sl1 ≠ [], sl3 ≠ [], sl4 ≠ [], # sl < # sl3, frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl4⌝ , ⌜al0⌝ ), frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al2⌝ ), # sl1 ≤ # sl4, ∀ sl2, al2. hd(sl2) = a ∧ sl2.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al2⌝ ) → # sl4 < # sl2, ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ |
(a ' + sl5).last = sl3.last, sl.last = sl3.last, sl4.last = sl3.last, sl ≠ [], sl3 ≠ [], sl4 ≠ [], # sl5 < # sl4, # sl < # sl3, frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl5⌝ , ⌜al2⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl4⌝ , ⌜al0⌝ ), ∀ sl2, al2. hd(sl2) = a ∧ sl2.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al2⌝ ) → # sl4 < # sl2, ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦
Used simplifier rules: ⊦ # x = 0 ↔ x = []; (s) f: ⊦ m < n → n ≠ 0; (forward) from specification nat-basic a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ a + x = a ' + x; (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 +1 = m + 1; (s) ⊦ #(a ' + x) = (# x)+1; (s) ⊦ a ' + x ≠ []; (s)
| (a ' + sl5).last = sl3.last, sl.last = sl3.last, sl4.last = sl3.last, sl ≠ [], sl3 ≠ [], sl4 ≠ [], # sl5 < # sl4, # sl < # sl3, frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl5⌝ , ⌜al2⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl4⌝ , ⌜al0⌝ ), ∀ sl2, al2. hd(sl2) = a ∧ sl2.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al2⌝ ) → # sl4 < # sl2, ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ |
sl4.last = sl3.last, sl.last = sl3.last, (a ' + sl5).last = sl3.last, sl5 = [], sl ≠ [], sl3 ≠ [], sl4 ≠ [], # sl < # sl3, # sl5 < # sl4, frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl4⌝ , ⌜al0⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl5⌝ , ⌜al2⌝ ), ∀ sl2, al2. hd(sl2) = a ∧ sl2.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al2⌝ ) → # sl4 < # sl2, ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦
sl4.last = sl3.last, sl.last = sl3.last, (a ' + sl5).last = sl3.last, sl ≠ [], sl3 ≠ [], sl4 ≠ [], sl5 ≠ [], # sl < # sl3, # sl5 < # sl4, frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl4⌝ , ⌜al0⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl5⌝ , ⌜al2⌝ ), ∀ sl2, al2. hd(sl2) = a ∧ sl2.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al2⌝ ) → # sl4 < # sl2, ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦
Used formulas: sl5 = []
| sl4.last = sl3.last, sl.last = sl3.last, (a ' + sl5).last = sl3.last, sl5 = [], sl ≠ [], sl3 ≠ [], sl4 ≠ [], # sl < # sl3, # sl5 < # sl4, frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl4⌝ , ⌜al0⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl5⌝ , ⌜al2⌝ ), ∀ sl2, al2. hd(sl2) = a ∧ sl2.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al2⌝ ) → # sl4 < # sl2, ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ |
sl4.last = sl3.last, sl.last = sl3.last, sl ≠ [], sl3 ≠ [], sl4 ≠ [], # sl < # sl3, frag(IOAut(startf, stepf))(⌜sl3.last '⌝ , ⌜al2⌝ ), frag(IOAut(startf, stepf))(⌜sl3.last '⌝ + ⌜sl4⌝ , ⌜al0⌝ ), frag(IOAut(startf, stepf))(⌜sl3.last '⌝ + ⌜sl⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜sl3.last '⌝ + ⌜sl3⌝ , ⌜al⌝ ), ∀ sl2, al2. hd(sl2) = sl3.last ∧ sl2.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al2⌝ ) → # sl4 < # sl2, ∀ sl0, startf, stepf, al. # sl0 < #(sl3.last + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦
Used simplifier rules: ⊦ # x = 0 ↔ x = []; (s) ⊦ 0 < m ↔ m ≠ 0; (s) ⊦ # [] = 0; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream[IOstatestream] ⊦ σ + [] = σ; (s) ⊦ ⌜[]⌝ = []; (s) ⊦ a '.last = a; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ x + [] = x; (s)
| sl4.last = sl3.last, sl.last = sl3.last, sl ≠ [], sl3 ≠ [], sl4 ≠ [], # sl < # sl3, frag(IOAut(startf, stepf))(⌜sl3.last '⌝ , ⌜al2⌝ ), frag(IOAut(startf, stepf))(⌜sl3.last '⌝ + ⌜sl4⌝ , ⌜al0⌝ ), frag(IOAut(startf, stepf))(⌜sl3.last '⌝ + ⌜sl⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜sl3.last '⌝ + ⌜sl3⌝ , ⌜al⌝ ), ∀ sl2, al2. hd(sl2) = sl3.last ∧ sl2.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al2⌝ ) → # sl4 < # sl2, ∀ sl0, startf, stepf, al. # sl0 < #(sl3.last + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ |
Used simplifier rules: ⊦ hd(a ') = a; (s) ⊦ a '.last = a; (s) ⊦ # a ' = 0 +1; (s) ⊦ m < 1 ↔ m = 0; (s) ⊦ # x = 0 ↔ x = []; (s) Used terms: sl3.last ', al2
| sl4.last = sl3.last, sl.last = sl3.last, (a ' + sl5).last = sl3.last, sl ≠ [], sl3 ≠ [], sl4 ≠ [], sl5 ≠ [], # sl < # sl3, # sl5 < # sl4, frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl4⌝ , ⌜al0⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl5⌝ , ⌜al2⌝ ), ∀ sl2, al2. hd(sl2) = a ∧ sl2.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al2⌝ ) → # sl4 < # sl2, ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ |
sl.last = sl3.last, sl4.last = sl3.last, sl5.last = sl3.last, sl ≠ [], sl3 ≠ [], sl4 ≠ [], sl5 ≠ [], # sl5 < # sl4, # sl < # sl3, frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl5⌝ , ⌜al2⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl4⌝ , ⌜al0⌝ ), ∀ sl2, al2. hd(sl2) = a ∧ sl2.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al2⌝ ) → # sl4 < # sl2, ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦
Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ x ≠ [] → (a ' + x).last = x.last; (s)
| sl.last = sl3.last, sl4.last = sl3.last, sl5.last = sl3.last, sl ≠ [], sl3 ≠ [], sl4 ≠ [], sl5 ≠ [], # sl5 < # sl4, # sl < # sl3, frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl5⌝ , ⌜al2⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl3⌝ , ⌜al⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl⌝ , ⌜al1⌝ ), frag(IOAut(startf, stepf))(⌜a '⌝ + ⌜sl4⌝ , ⌜al0⌝ ), ∀ sl2, al2. hd(sl2) = a ∧ sl2.last = sl3.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al2⌝ ) → # sl4 < # sl2, ∀ sl0, startf, stepf, al. # sl0 < #(a + sl3) → frag(IOAut(startf, stepf))(⌜sl0⌝ , ⌜al⌝ ) → (∃ sl1, al0. hd(sl1) = hd(sl0) ∧ sl1.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl1⌝ , ⌜al0⌝ ) ∧ (∀ sl2, al1. hd(sl2) = hd(sl0) ∧ sl2.last = sl0.last ∧ frag(IOAut(startf, stepf))(⌜sl2⌝ , ⌜al1⌝ ) → # sl1 ≤ # sl2)) ⊦ |
Used simplifier rules: ⊦ hd(a ' + x) = a; (s) ⊦ x ≠ [] → (a ' + x).last = x.last; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ #(a ' + x) = (# x)+1; (s) ⊦ m +1 = m + 1; (s) a: ⊦ (x + y) + z = x + y + z; from specification list[IOstatestream] ⊦ m < n + 1 ↔ ¬ 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: a ' + sl5, al2
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.