Proof step 1 from proof repls-mon (conclusion) (back to tree)

⊦ nounsharedextR(cren, cext, ren) ∧ Πok(ext, cext, ren, cren) ∧ fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf) ∧ frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα) ∧ cext !(πra(step, cstep, ren, cren, (s, cs) + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα) → ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) + pcsf.take(n), paf.take(n), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) + pcsf.take(n + 1), paf.take(n + 1), ⌜as '⌝ + aσ, aα)⌝

System applied rule normalize

And obtained the following new goals

Proof step 2:
frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, (s, cs) + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) + pcsf.take(n), paf.take(n), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) + pcsf.take(n + 1), paf.take(n + 1), ⌜as '⌝ + aσ, aα)⌝ ⊦

Rule argument

Additional information

Proof step 2 from proof repls-mon (previous step) (back to tree)

frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, (s, cs) + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) + pcsf.take(n), paf.take(n), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) + pcsf.take(n + 1), paf.take(n + 1), ⌜as '⌝ + aσ, aα)⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 3:
frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf.take(n), paf.take(n), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf.take(n + 1), paf.take(n + 1), ⌜as '⌝ + aσ, aα)⌝ ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ a + x = a ' + x; (s) ⊦ a + σ = ⌜a '⌝ + σ; (s)

Proof step 3 from proof repls-mon (previous step) (back to tree)

frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf.take(n), paf.take(n), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf.take(n + 1), paf.take(n + 1), ⌜as '⌝ + aσ, aα)⌝ ⊦

User applied rule structural induction

And obtained the following new goals

Proof step 4:
frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf.take(0), paf.take(0), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf.take(0 + 1), paf.take(0 + 1), ⌜as '⌝ + aσ, aα)⌝ ⊦
Proof step 52:
frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf.take(n0 +1), paf.take(n0 +1), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf.take(n0 +1 + 1), paf.take(n0 +1 + 1), ⌜as '⌝ + aσ, aα)⌝ , ∀ astart, astep, aext, as, aσ, aα, start, cstart, step, cstep, ren, cren, ext, cext, s, cs, pcsf, paf, aren. ¬ ( frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα) ∧ fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf) ∧ nounsharedextR(cren, cext, ren) ∧ Πok(ext, cext, ren, cren) ∧ cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα) ∧ ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf.take(n0), paf.take(n0), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf.take(n0 + 1), paf.take(n0 + 1), ⌜as '⌝ + aσ, aα)⌝ ) ⊦

Rule argument

term: n

Additional information

Used simplifier rules: Nat freely generated by 0, +1;;

Proof step 4 from proof repls-mon (previous step) (back to tree)

frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf.take(0), paf.take(0), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf.take(0 + 1), paf.take(0 + 1), ⌜as '⌝ + aσ, aα)⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 5:
frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf(0) ', paf(0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

Rule argument

Additional information

Used simplifier rules: repls-base: ⊦ repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ', [], ⌜as '⌝ + aσ, aα) = (s, as) '; ⊦ nf.take(1) = nf(0) '; (s) c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream ⊦ nf.take(0) = []; (s) a: ⊦ (x + y) + z = x + y + z; from specification list ⊦ x + [] = x; (s)

Proof step 5 from proof repls-mon (previous step) (back to tree)

frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf(0) ', paf(0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

User applied rule structural induction

And obtained the following new goals

Proof step 6:
(s0, cs0) = pcsf(0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf(0) ', paf(0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

Rule argument

term: pcsf(0)

Additional information

Proof step 6 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf(0) ', paf(0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 7:
(s0, cs0) = pcsf(0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', paf(0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

Rule argument

Additional information

Proof step 7 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', paf(0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Proof step 8:
⊦ fragω(IOAut(start, step, ext))(s ' + sf, af) ↔ step(s, af(0), sf(0)) ∧ fragω(IOAut(start, step, ext))(sf, λ n. af(n + 1))
Proof step 9:
(s0, cs0) = pcsf(0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Π(step, cstep, ren, cren, ext, cext)((s, cs), paf(0), pcsf(0)), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', paf(0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

Rule argument

spec: IOtrace, name:inffrag-rec1, seq:⊦ fragω(IOAut(start, step, ext))(s ' + sf, af) ↔ step(s, af(0), sf(0)) ∧ fragω(IOAut(start, step, ext))(sf, λ n. af(n + 1)), subst:[step, s, start, sf, ext, af] → [Π(step, cstep, ren, cren, ext, cext), (s, cs), Π(start, cstart), pcsf, Π(ext, cext, ren, cren), paf]; ['s, 'a, 'e] → [('s, 'cs), 'pa, 'e], <all paths>

Additional information

Used terms: (s, cs), Π(ext, cext, ren, cren), Π(start, cstart), pcsf, paf, Π(step, cstep, ren, cren, ext, cext)

Proof step 8 from proof repls-mon (previous step) (back to tree)

⊦ fragω(IOAut(start, step, ext))(s ' + sf, af) ↔ step(s, af(0), sf(0)) ∧ fragω(IOAut(start, step, ext))(sf, λ n. af(n + 1))

A spec-lemma

Proof step 9 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Π(step, cstep, ren, cren, ext, cext)((s, cs), paf(0), pcsf(0)), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', paf(0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 10:
(s0, cs0) = pcsf(0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Π(step, cstep, ren, cren, ext, cext)((s, cs), paf(0), (s0, cs0)), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', paf(0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

Rule argument

Additional information

Proof step 10 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Π(step, cstep, ren, cren, ext, cext)((s, cs), paf(0), (s0, cs0)), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', paf(0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Proof step 11:
⊦ Π(lstep, rstep, lren, rren, lext, rext)((ls, rs), pa, (ls0, rs0)) ↔ rs = rs0 ∧ (∃ la. lstep(ls, la, ls0) ∧ pa = lren(la) ∧ ¬ cod(rren)(pa)) ∨ ls = ls0 ∧ (∃ ra. rstep(rs, ra, rs0) ∧ pa = rren(ra) ∧ ¬ cod(lren)(pa)) ∨ (∃ la, ra. lstep(ls, la, ls0) ∧ lext(la) ≠ None ∧ pa = lren(la) ∧ rstep(rs, ra, rs0) ∧ rext(ra) ≠ None ∧ pa = rren(ra))
Proof step 12:
(s0, cs0) = pcsf(0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', paf(0) ', ⌜as '⌝ + aσ, aα)⌝ , cs = cs0 ∧ (∃ la. step(s, la, s0) ∧ paf(0) = ren(la) ∧ ¬ cod(cren)(paf(0))) ∨ s = s0 ∧ (∃ ra. cstep(cs, ra, cs0) ∧ paf(0) = cren(ra) ∧ ¬ cod(ren)(paf(0))) ∨ (∃ la, ra. step(s, la, s0) ∧ ext(la) ≠ None ∧ paf(0) = ren(la) ∧ cstep(cs, ra, cs0) ∧ cext(ra) ≠ None ∧ paf(0) = cren(ra)) ⊦

Rule argument

spec: product, name:lrstep-def, seq:⊦ Π(lstep, rstep, lren, rren, lext, rext)((ls, rs), pa, (ls0, rs0)) ↔ rs = rs0 ∧ (∃ la. lstep(ls, la, ls0) ∧ pa = lren(la) ∧ ¬ cod(rren)(pa)) ∨ ls = ls0 ∧ (∃ ra. rstep(rs, ra, rs0) ∧ pa = rren(ra) ∧ ¬ cod(lren)(pa)) ∨ (∃ la, ra. lstep(ls, la, ls0) ∧ lext(la) ≠ None ∧ pa = lren(la) ∧ rstep(rs, ra, rs0) ∧ rext(ra) ≠ None ∧ pa = rren(ra)), subst:[pa, ls0, rext, lstep, rs0, ls, rs, rren, lren, lext, rstep] → [paf(0), s0, cext, step, cs0, s, cs, cren, ren, ext, cstep]; ['ls, 'ra, 'la, 'pa, 'rs, 'e] → ['s, 'ca, 'a, 'pa, 'cs, 'e], <all paths>

Additional information

Used terms: cext, paf(0), cs, cstep, ren, ext, cren, cs0, step, s, s0

Proof step 11 from proof repls-mon (previous step) (back to tree)

⊦ Π(lstep, rstep, lren, rren, lext, rext)((ls, rs), pa, (ls0, rs0)) ↔ rs = rs0 ∧ (∃ la. lstep(ls, la, ls0) ∧ pa = lren(la) ∧ ¬ cod(rren)(pa)) ∨ ls = ls0 ∧ (∃ ra. rstep(rs, ra, rs0) ∧ pa = rren(ra) ∧ ¬ cod(lren)(pa)) ∨ (∃ la, ra. lstep(ls, la, ls0) ∧ lext(la) ≠ None ∧ pa = lren(la) ∧ rstep(rs, ra, rs0) ∧ rext(ra) ≠ None ∧ pa = rren(ra))

A spec-lemma

Proof step 12 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', paf(0) ', ⌜as '⌝ + aσ, aα)⌝ , cs = cs0 ∧ (∃ la. step(s, la, s0) ∧ paf(0) = ren(la) ∧ ¬ cod(cren)(paf(0))) ∨ s = s0 ∧ (∃ ra. cstep(cs, ra, cs0) ∧ paf(0) = cren(ra) ∧ ¬ cod(ren)(paf(0))) ∨ (∃ la, ra. step(s, la, s0) ∧ ext(la) ≠ None ∧ paf(0) = ren(la) ∧ cstep(cs, ra, cs0) ∧ cext(ra) ≠ None ∧ paf(0) = cren(ra)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 13:
(s0, cs0) = pcsf(0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', paf(0) ', ⌜as '⌝ + aσ, aα)⌝ , cs = cs0 ∧ step(s, a, s0) ∧ paf(0) = ren(a) ∧ ¬ cod(cren)(paf(0)) ∨ s = s0 ∧ cstep(cs, ca, cs0) ∧ paf(0) = cren(ca) ∧ ¬ cod(ren)(paf(0)) ∨ step(s, a0, s0) ∧ ext(a0) ≠ None ∧ paf(0) = ren(a0) ∧ cstep(cs, ca0, cs0) ∧ cext(ca0) ≠ None ∧ paf(0) = cren(ca0) ⊦

Rule argument

Additional information

Proof step 13 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', paf(0) ', ⌜as '⌝ + aσ, aα)⌝ , cs = cs0 ∧ step(s, a, s0) ∧ paf(0) = ren(a) ∧ ¬ cod(cren)(paf(0)) ∨ s = s0 ∧ cstep(cs, ca, cs0) ∧ paf(0) = cren(ca) ∧ ¬ cod(ren)(paf(0)) ∨ step(s, a0, s0) ∧ ext(a0) ≠ None ∧ paf(0) = ren(a0) ∧ cstep(cs, ca0, cs0) ∧ cext(ca0) ≠ None ∧ paf(0) = cren(ca0) ⊦

User applied rule case distinction

And obtained the following new goals

Proof step 14:
(s0, cs0) = pcsf(0), cs = cs0, paf(0) = ren(a), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ cod(cren)(paf(0)), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', paf(0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦
Proof step 17:
(s0, cs0) = pcsf(0), paf(0) = cren(ca), s = s0, cstep(cs, ca, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ cod(ren)(paf(0)), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', paf(0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦
Proof step 20:
(s0, cs0) = pcsf(0), paf(0) = ren(a0), paf(0) = cren(ca0), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', paf(0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

Rule argument

pos: left 8

Additional information

Proof step 14 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), cs = cs0, paf(0) = ren(a), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ cod(cren)(paf(0)), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', paf(0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 15:
(s0, cs0) = pcsf(0), paf(0) = ren(a), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs0) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ cod(cren)(ren(a)), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs0) ' + (s0, cs0) ', ren(a) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

Rule argument

Additional information

Proof step 15 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), paf(0) = ren(a), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs0) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ cod(cren)(ren(a)), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs0) ' + (s0, cs0) ', ren(a) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

User applied rule apply lemma

And obtained the following new goals

Proof step 16:
⊦ step(s, a, s0) ∧ ¬ cod(cren)(ren(a)) → repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs) ' + pcsl, ren(a) ' + pal, ⌜as '⌝ + aσ, aα) = (s, as) ' + repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs) ' + pcsl, pal, ⌜as '⌝ + aσ, aα)

Rule argument

spec: <toplevel>, name:repls-rec-addS, seq:⊦ step(s, a, s0) ∧ ¬ cod(cren)(ren(a)) → repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs) ' + pcsl, ren(a) ' + pal, ⌜as '⌝ + aσ, aα) = (s, as) ' + repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs) ' + pcsl, pal, ⌜as '⌝ + aσ, aα), subst:[a, as, aσ, cren, ren, cstep, aren, pcsl, aext, step, pal, cs, cext, s0, aα, s] → [a, as, aσ, cren, ren, cstep, aren, [], aext, step, [], cs0, cext, s0, aα, s]; ['ca, 'cs, 'a, 'aa, 'pa, 'e, 's, 'as] → ['ca, 'cs, 'a, 'aa, 'pa, 'e, 's, 'as]

Additional information

Used simplifier rules: repls-base: ⊦ repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ', [], ⌜as '⌝ + aσ, aα) = (s, as) '; ⊦ x + [] = x; (s) in-14: ⊦ a ' + x = y → a ∈ y; (forward) from specification list in-15: ⊦ x + a ' = y → a ∈ y; (forward) from specification list ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) a: ⊦ (x + y) + z = x + y + z; from specification list ⊦ σ1 ⊑ σ1 + σ2; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream Used terms: aren, ren, cstep, cext, s, as, aext, aα, a, [], cren, [], s0, cs0, aσ, step

Proof step 16 from proof repls-mon (previous step) (back to tree)

⊦ step(s, a, s0) ∧ ¬ cod(cren)(ren(a)) → repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs) ' + pcsl, ren(a) ' + pal, ⌜as '⌝ + aσ, aα) = (s, as) ' + repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs) ' + pcsl, pal, ⌜as '⌝ + aσ, aα)

Lemma repls-rec-addS

Proof step 17 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), paf(0) = cren(ca), s = s0, cstep(cs, ca, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ cod(ren)(paf(0)), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', paf(0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 18:
(s0, cs0) = pcsf(0), paf(0) = cren(ca), cstep(cs, ca, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s0, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ cod(ren)(cren(ca)), ¬ ⌜(s0, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs) ' + (s0, cs0) ', cren(ca) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

Rule argument

Additional information

Proof step 18 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), paf(0) = cren(ca), cstep(cs, ca, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s0, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ cod(ren)(cren(ca)), ¬ ⌜(s0, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs) ' + (s0, cs0) ', cren(ca) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

User applied rule apply lemma

And obtained the following new goals

Proof step 19:
⊦ cstep(cs, ca, cs0) ∧ ¬ cod(ren)(cren(ca)) → repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s, cs0) ' + pcsl, cren(ca) ' + pal, ⌜as '⌝ + aσ, aα) = repls(step, cstep, cren, ren, aren, cext, aext, (s, cs0) ' + pcsl, pal, ⌜as '⌝ + aσ, aα)

Rule argument

spec: <toplevel>, name:repls-rec-skip, seq:⊦ cstep(cs, ca, cs0) ∧ ¬ cod(ren)(cren(ca)) → repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s, cs0) ' + pcsl, cren(ca) ' + pal, ⌜as '⌝ + aσ, aα) = repls (step, cstep, cren, ren, aren, cext, aext, (s, cs0) ' + pcsl, pal, ⌜as '⌝ + aσ, aα), subst:[ca, as, aσ, cren, ren, cstep, aren, pcsl, aext, step, pal, cs, cext, cs0, aα, s] → [ca, as, aσ, cren, ren, cstep, aren, [], aext, step, [], cs, cext, cs0, aα, s0]; ['ca, 'cs, 'a, 'aa, 'pa, 'e, 's, 'as] → ['ca, 'cs, 'a, 'aa, 'pa, 'e, 's, 'as]

Additional information

Used simplifier rules: repls-base: ⊦ repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ', [], ⌜as '⌝ + aσ, aα) = (s, as) '; ⊦ x + [] = x; (s) a: ⊦ (x + y) + z = x + y + z; from specification list append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream ⊦ σ ⊑ σ; (s) Used terms: aren, ren, cstep, cext, s0, as, aext, aα, ca, [], cren, [], cs0, cs, aσ, step

Proof step 19 from proof repls-mon (previous step) (back to tree)

⊦ cstep(cs, ca, cs0) ∧ ¬ cod(ren)(cren(ca)) → repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s, cs0) ' + pcsl, cren(ca) ' + pal, ⌜as '⌝ + aσ, aα) = repls(step, cstep, cren, ren, aren, cext, aext, (s, cs0) ' + pcsl, pal, ⌜as '⌝ + aσ, aα)

Lemma repls-rec-skip

Proof step 20 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), paf(0) = ren(a0), paf(0) = cren(ca0), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', paf(0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 21:
(s0, cs0) = pcsf(0), paf(0) = cren(ca0), ren(a0) = cren(ca0), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

Rule argument

Additional information

Proof step 21 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), paf(0) = cren(ca0), ren(a0) = cren(ca0), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

User applied rule apply lemma

And obtained the following new goals

Proof step 22:
pa = rren(ra) ⊦ Πok(lext, rext, lren, rren) ∧ fragω(IOAut(Π(lstart, rstart), Π(lstep, rstep, lren, rren, lext, rext), Π(lext, rext, lren, rren)))((ls0, rs0) ' + psf, paf) ∧ lstep(ls, la, ls0) ∧ rstep(rs, ra, rs0) ∧ lren(la) = rren(ra) → πra(lstep, rstep, lren, rren, ⌜(ls, rs) '⌝ + ⌜(ls0, rs0) '⌝ + ⌜psf⌝ , pa + ⌜paf⌝ ) = ⌜ra '⌝ + πra(lstep, rstep, lren, rren, ⌜(ls0, rs0) '⌝ + ⌜psf⌝ , ⌜paf⌝ )
Proof step 23:
(s0, cs0) = pcsf(0), paf(0) = cren(ca0), ren(a0) = cren(ca0), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ , Πok(ext, cext, ren, cren) ∧ fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s0, cs0) ' + (λ n. pcsf(n + 1)), λ n. paf(n + 1)) ∧ step(s, a0, s0) ∧ cstep(cs, ca0, cs0) ∧ ren(a0) = cren(ca0) → πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ren(a0) + ⌜λ n. paf(n + 1)⌝ ) = ⌜ca0 '⌝ + πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ) ⊦

Rule argument

spec: project-right, name:projaction-infrec-addboth, seq:pa = rren(ra) ⊦ Πok(lext, rext, lren, rren) ∧ fragω (IOAut (Π(lstart, rstart), Π(lstep, rstep, lren, rren, lext, rext), Π(lext, rext, lren, rren))) ((ls0, rs0) ' + psf, paf) ∧ lstep(ls, la, ls0) ∧ rstep(rs, ra, rs0) ∧ lren(la) = rren(ra) → πra (lstep, rstep, lren, rren, ⌜(ls, rs) '⌝ + ⌜(ls0, rs0) '⌝ + ⌜psf⌝ , pa + ⌜paf⌝ ) = ⌜ra '⌝ + πra(lstep, rstep, lren, rren, ⌜(ls0, rs0) '⌝ + ⌜psf⌝ , ⌜paf⌝ ), subst:[psf, lstart, pa, ls0, rstart, rext, lstep, ra, ls, rren, rs0, la, lren, lext, rstep, rs, paf] → [λ n. pcsf(n + 1), start, ren(a0), s0, cstart, cext, step, ca0, s, cren, cs0, a0, ren, ext, cstep, cs, λ n. paf(n + 1)]; ['ls, 'ra, 'la, 'pa, 'rs, 'e] → ['s, 'ca, 'a, 'pa, 'cs, 'e]

Additional information

Used terms: cext, ren(a0), cs, cstart, cstep, λ n. pcsf(n + 1), ca0, ren, ext, cren, a0, cs0, step, start, λ n. paf(n + 1), s, s0

Proof step 22 from proof repls-mon (previous step) (back to tree)

pa = rren(ra) ⊦ Πok(lext, rext, lren, rren) ∧ fragω(IOAut(Π(lstart, rstart), Π(lstep, rstep, lren, rren, lext, rext), Π(lext, rext, lren, rren)))((ls0, rs0) ' + psf, paf) ∧ lstep(ls, la, ls0) ∧ rstep(rs, ra, rs0) ∧ lren(la) = rren(ra) → πra(lstep, rstep, lren, rren, ⌜(ls, rs) '⌝ + ⌜(ls0, rs0) '⌝ + ⌜psf⌝ , pa + ⌜paf⌝ ) = ⌜ra '⌝ + πra(lstep, rstep, lren, rren, ⌜(ls0, rs0) '⌝ + ⌜psf⌝ , ⌜paf⌝ )

A spec-lemma

Proof step 23 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), paf(0) = cren(ca0), ren(a0) = cren(ca0), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ , Πok(ext, cext, ren, cren) ∧ fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s0, cs0) ' + (λ n. pcsf(n + 1)), λ n. paf(n + 1)) ∧ step(s, a0, s0) ∧ cstep(cs, ca0, cs0) ∧ ren(a0) = cren(ca0) → πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ren(a0) + ⌜λ n. paf(n + 1)⌝ ) = ⌜ca0 '⌝ + πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 24:
(s0, cs0) = pcsf(0), paf(0) = cren(ca0), ren(a0) = cren(ca0), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ , fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s0, cs0) ' + (λ n. pcsf(n + 1)), λ n. paf(n + 1)) → πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ ) = ⌜ca0 '⌝ + πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ a + σ = ⌜a '⌝ + σ; (s)

Proof step 24 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), paf(0) = cren(ca0), ren(a0) = cren(ca0), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ , fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s0, cs0) ' + (λ n. pcsf(n + 1)), λ n. paf(n + 1)) → πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ ) = ⌜ca0 '⌝ + πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ) ⊦

User applied rule cut formula

And obtained the following new goals

Proof step 25:
(s0, cs0) = pcsf(0), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ , fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s0, cs0) ' + (λ n. pcsf(n + 1)), λ n. paf(n + 1)) → πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ ) = ⌜ca0 '⌝ + πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ) ⊦
Proof step 47:
(s0, cs0) = pcsf(0), paf(0) = cren(ca0), ren(a0) = cren(ca0), cext(ca0) ≠ None, ext(a0) ≠ None, pcsf ≠ (s0, cs0) ' + (λ n. pcsf(n + 1)), cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ , fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s0, cs0) ' + (λ n. pcsf(n + 1)), λ n. paf(n + 1)) → πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ ) = ⌜ca0 '⌝ + πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ) ⊦

Rule argument

fma: pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1))

Additional information

Used formulas: pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1))

Proof step 25 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ , fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s0, cs0) ' + (λ n. pcsf(n + 1)), λ n. paf(n + 1)) → πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ ) = ⌜ca0 '⌝ + πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 26:
(s0, cs0) = pcsf(0), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ ) = ⌜ca0 '⌝ + πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

Rule argument

Additional information

Proof step 26 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ ) = ⌜ca0 '⌝ + πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Proof step 27:
⊦ ⌜nf⌝ = nf(0) + ⌜λ n. nf(n + 1)⌝
Proof step 28:
(s0, cs0) = pcsf(0), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ ) = ⌜ca0 '⌝ + πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , paf(0) + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

Rule argument

spec: stream, name:intrace-expand, seq: ⊦ ⌜nf⌝ = nf(0) + ⌜λ n. nf(n + 1)⌝ , subst:[nf] → [paf]; ['a] → ['pa], <all paths>

Additional information

Used terms: paf

Proof step 27 from proof repls-mon (previous step) (back to tree)

⊦ ⌜nf⌝ = nf(0) + ⌜λ n. nf(n + 1)⌝

A spec-lemma

Proof step 28 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ ) = ⌜ca0 '⌝ + πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , paf(0) + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 29:
(s0, cs0) = pcsf(0), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ ) = ⌜ca0 '⌝ + πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ a + σ = ⌜a '⌝ + σ; (s)

Proof step 29 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ ) = ⌜ca0 '⌝ + πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

User applied rule subst equation

And obtained the following new goals

Proof step 30:
(s0, cs0) = (((s0, cs0) ' + (λ n. pcsf(n + 1))))(0), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), πra (step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. (((s0, cs0) ' + (λ n. pcsf(n + 1))))(n + 1)⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ ) = ⌜ca0 '⌝ + πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. (((s0, cs0) ' + (λ n. pcsf(n + 1))))(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s0, cs0) ' + (λ n. pcsf(n + 1)), λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) ' + (λ n. pcsf(n + 1))⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

Rule argument

pos: left 3, flags:

Additional information

Proof step 30 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = (((s0, cs0) ' + (λ n. pcsf(n + 1))))(0), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), πra (step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. (((s0, cs0) ' + (λ n. pcsf(n + 1))))(n + 1)⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ ) = ⌜ca0 '⌝ + πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. (((s0, cs0) ' + (λ n. pcsf(n + 1))))(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s0, cs0) ' + (λ n. pcsf(n + 1)), λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) ' + (λ n. pcsf(n + 1))⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

User applied rule simplifier

And obtained the following new goals

Proof step 31:
(s0, cs0) = pcsf(0), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ ) = ⌜ca0 '⌝ + πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

Rule argument

Additional information

Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream ⊦ ⌜x + nf⌝ = ⌜x⌝ + ⌜nf⌝ ; (s)

Proof step 31 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ ) = ⌜ca0 '⌝ + πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

User applied rule subst equation

And obtained the following new goals

Proof step 32:
(s0, cs0) = pcsf(0), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(⌜ca0 '⌝ + πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

Rule argument

pos: left 5, flags: discard

Additional information

Proof step 32 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(⌜ca0 '⌝ + πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 33:
(s0, cs0) = pcsf(0), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ⌜cext(ca0).get '⌝ + cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

Rule argument

Additional information

Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream ⊦ ext(a) ≠ None → ext !(⌜a '⌝ + α) = ⌜ext(a).get '⌝ + ext !(α); (s)

Proof step 33 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ⌜cext(ca0).get '⌝ + cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

Heuristic elimination applied rule apply elim lemma

And obtained the following new goals

Proof step 34:
(s0, cs0) = pcsf(0), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ⌜e '⌝ + cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

Rule argument

spec: option, name:elim-Some, seq: ⊦ opt ≠ None → (get = opt.get ↔ opt = Some(get)), subst:[opt, get] → [cext(ca0), e]; ['a] → ['e]

Additional information

Used simplifier rules: ⊦ opt ≠ None → (get = opt.get ↔ opt = Some(get)); (elim) Used terms: cext(ca0), e

Proof step 34 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ⌜e '⌝ + cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 35:
(s0, cs0) = pcsf(0), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), Some(e) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ⌜e '⌝ + cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

Rule argument

Additional information

Proof step 35 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), Some(e) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ⌜e '⌝ + cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Proof step 36:
⊦ σ ⊑ σ0 ↔ (∃ σ1. σ + σ1 = σ0)
Proof step 37:
(s0, cs0) = pcsf(0), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), Some(e) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ , ∃ σ1. (⌜e '⌝ + cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ))) + σ1 = aext !(aα) ⊦

Rule argument

spec: stream, name: prefix-def, seq: ⊦ σ ⊑ σ0 ↔ (∃ σ1. σ + σ1 = σ0), subst:[σ, σ0] → [ ⌜e '⌝ + cext ! (πra (step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )), aext !(aα)]; ['a] → ['e], <all paths>

Additional information

Used terms: ⌜e '⌝ + cext ! (πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )), aext !(aα)

Proof step 36 from proof repls-mon (previous step) (back to tree)

⊦ σ ⊑ σ0 ↔ (∃ σ1. σ + σ1 = σ0)

A spec-lemma

Proof step 37 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), Some(e) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ , ∃ σ1. (⌜e '⌝ + cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ))) + σ1 = aext !(aα) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 38:
(s0, cs0) = pcsf(0), (⌜e '⌝ + cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ))) + β = aext !(aα), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), Some(e) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

Rule argument

Additional information

Proof step 38 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), (⌜e '⌝ + cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ))) + β = aext !(aα), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), Some(e) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Proof step 39:
⊦ ext !(α) = ⌜e '⌝ + β ↔ (∃ al, a, α0. α = ⌜al⌝ + ⌜a '⌝ + α0 ∧ ext(a) = Some(e) ∧ ext !(⌜al⌝ ) = [] ∧ ext !(α0) = β)
Proof step 40:
(s0, cs0) = pcsf(0), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), Some(e) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ , ∃ al, aa, α0. aα = ⌜al⌝ + ⌜aa '⌝ + α0 ∧ aext(aa) = Some(e) ∧ aext !(⌜al⌝ ) = [] ∧ aext !(α0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β ⊦

Rule argument

spec: remtau, name: remtau-split-one, seq:⊦ ext !(α) = ⌜e '⌝ + β ↔ (∃ al, a, α0. α = ⌜al⌝ + ⌜a '⌝ + α0 ∧ ext(a) = Some(e) ∧ ext !(⌜al⌝ ) = [] ∧ ext !(α0) = β), subst:[e, β, ext, α] → [e, cext ! (πra (step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, aext, aα]; ['e, 'a] → ['e, 'aa], <all paths>

Additional information

Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream Used terms: e, cext ! (πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, aext, aα

Proof step 39 from proof repls-mon (previous step) (back to tree)

⊦ ext !(α) = ⌜e '⌝ + β ↔ (∃ al, a, α0. α = ⌜al⌝ + ⌜a '⌝ + α0 ∧ ext(a) = Some(e) ∧ ext !(⌜al⌝ ) = [] ∧ ext !(α0) = β)

A spec-lemma

Proof step 40 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), Some(e) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ , ∃ al, aa, α0. aα = ⌜al⌝ + ⌜aa '⌝ + α0 ∧ aext(aa) = Some(e) ∧ aext !(⌜al⌝ ) = [] ∧ aext !(α0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 41:
aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, aext !(aal) = [], (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), Some(e) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0)⌝ ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜x⌝ = [] ↔ x = []; (s) ⊦ ext !(⌜al⌝ ) = ⌜ext !(al)⌝ ; (s)

Proof step 41 from proof repls-mon (previous step) (back to tree)

aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, aext !(aal) = [], (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), Some(e) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0)⌝ ⊦

User applied rule apply lemma

And obtained the following new goals

Proof step 42:
⊦ step(s, a, s0) ∧ cstep(cs, ca, cs0) ∧ aext !(⌜aal⌝ ) = [] ∧ cext(ca) = aext(aa) ∧ cren(ca) = ren(a) ∧ n = # aal → repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + pcsl, ren(a) ' + pal, aσ, ⌜aal⌝ + ⌜aa '⌝ + aα) = lift(aσ.take(n), s) + (s, aσ[n]) ' + repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + pcsl, pal, aσ.drop(n + 1), aα)
Proof step 43:
aext !(aal) = [], aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), Some(e) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0)⌝ , step(s, a0, s0) ∧ cstep(cs, ca0, cs0) ∧ aext !(⌜aal⌝ ) = [] ∧ cext(ca0) = aext(aa) ∧ cren(ca0) = ren(a0) ∧ # aal = # aal → repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + [], ren(a0) ' + [], as + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0) = lift((as + aσ).take(# aal), s) + (s, (as + aσ)[# aal]) ' + repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + [], [], (as + aσ).drop(# aal + 1), aα0) ⊦

Rule argument

spec: <toplevel>, name:repls-rec-addboth, seq:⊦ step(s, a, s0) ∧ cstep(cs, ca, cs0) ∧ aext !(⌜aal⌝ ) = [] ∧ cext(ca) = aext(aa) ∧ cren(ca) = ren(a) ∧ n = # aal → repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + pcsl, ren(a) ' + pal, aσ, ⌜aal⌝ + ⌜aa '⌝ + aα) = lift(aσ.take(n), s) + (s, aσ[n]) ' + repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + pcsl, pal, aσ.drop(n + 1), aα), subst:[ca, a, aal, aa, aσ, cren, ren, n, cstep, aren, pcsl, aext, step, pal, cs, cext, s0, cs0, aα, s] → [ca0, a0, aal, aa, as + aσ, cren, ren, # aal, cstep, aren, [], aext, step, [], cs, cext, s0, cs0, aα0, s]; ['ca, 'cs, 'a, 'aa, 'pa, 'e, 's, 'as] → ['ca, 'cs, 'a, 'aa, 'pa, 'e, 's, 'as]

Additional information

Used terms: aren, ren, cstep, cext, aa, s, aext, aα0, ca0, a0, [], cren, aal, [], cs0, s0, cs, # aal, as + aσ, step

Proof step 42 from proof repls-mon (previous step) (back to tree)

⊦ step(s, a, s0) ∧ cstep(cs, ca, cs0) ∧ aext !(⌜aal⌝ ) = [] ∧ cext(ca) = aext(aa) ∧ cren(ca) = ren(a) ∧ n = # aal → repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + pcsl, ren(a) ' + pal, aσ, ⌜aal⌝ + ⌜aa '⌝ + aα) = lift(aσ.take(n), s) + (s, aσ[n]) ' + repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + pcsl, pal, aσ.drop(n + 1), aα)

Lemma repls-rec-addboth

Proof step 43 from proof repls-mon (previous step) (back to tree)

aext !(aal) = [], aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), Some(e) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0)⌝ , step(s, a0, s0) ∧ cstep(cs, ca0, cs0) ∧ aext !(⌜aal⌝ ) = [] ∧ cext(ca0) = aext(aa) ∧ cren(ca0) = ren(a0) ∧ # aal = # aal → repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + [], ren(a0) ' + [], as + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0) = lift((as + aσ).take(# aal), s) + (s, (as + aσ)[# aal]) ' + repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + [], [], (as + aσ).drop(# aal + 1), aα0) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 44:
aext !(aal) = [], aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0) = lift((⌜as '⌝ + aσ).take(# aal), s) + (s, (⌜as '⌝ + aσ)[# aal]) ' + repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ', [], aσ.drop(# aal), aα0), Some(e) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0)⌝ ⊦

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n + 0 = n; (s) ⊦ n ≠ 0 → (⌜a '⌝ + σ).drop((* n) + m) = σ.drop((n - 1) + m); (s) ⊦ a + σ = ⌜a '⌝ + σ; (s) ⊦ x + [] = x; (s) ⊦ ⌜x⌝ = [] ↔ x = []; (s) ⊦ ext !(⌜al⌝ ) = ⌜ext !(al)⌝ ; (s)

Proof step 44 from proof repls-mon (previous step) (back to tree)

aext !(aal) = [], aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0) = lift((⌜as '⌝ + aσ).take(# aal), s) + (s, (⌜as '⌝ + aσ)[# aal]) ' + repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ', [], aσ.drop(# aal), aα0), Some(e) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0)⌝ ⊦

User applied rule subst equation

And obtained the following new goals

Proof step 45:
aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, aext !(aal) = [], (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), Some(e) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ ⌜(s, as) '⌝ ⊑ ⌜ lift((⌜as '⌝ + aσ).take(# aal), s) + (s, (⌜as '⌝ + aσ)[# aal]) ' + repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ', [], aσ.drop(# aal), aα0) ⌝ ⊦

Rule argument

pos: left 9, flags: discard

Additional information

Proof step 45 from proof repls-mon (previous step) (back to tree)

aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, aext !(aal) = [], (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), Some(e) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ ⌜(s, as) '⌝ ⊑ ⌜ lift((⌜as '⌝ + aσ).take(# aal), s) + (s, (⌜as '⌝ + aσ)[# aal]) ' + repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ', [], aσ.drop(# aal), aα0) ⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 46:
aext !(aal) = [], aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), Some(e) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ ⌜(s, as) '⌝ ⊑ ⌜lift((⌜as '⌝ + aσ).take(# aal), s)⌝ + ⌜(s, (⌜as '⌝ + aσ)[# aal]) '⌝ + ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ', [], aσ.drop(# aal), aα0)⌝ ⊦

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s)

Proof step 46 from proof repls-mon (previous step) (back to tree)

aext !(aal) = [], aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), Some(e) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ ⌜(s, as) '⌝ ⊑ ⌜lift((⌜as '⌝ + aσ).take(# aal), s)⌝ + ⌜(s, (⌜as '⌝ + aσ)[# aal]) '⌝ + ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ', [], aσ.drop(# aal), aα0)⌝ ⊦

User applied rule constructor cut

And closed the goal!

Rule argument

var: aal

Additional information

Used simplifier rules: lift-base: ⊦ lift([], s) = []; lift-rec: ⊦ lift(as ' + asl, s) = (s, as) ' + lift(asl, s); List('a) freely generated by [], +;; ⊦ ext !(al + al0) = ext !(al) + ext !(al0); (s) ⊦ x + y = [] ↔ x = [] ∧ y = []; (s) ⊦ ext !(a ') = [] ↔ ext(a) = None; (s) ⊦ n ≠ 0 → (⌜a '⌝ + σ).take((* n) + m) = a ' + σ.take((n - 1) + m); (s) ⊦ n + 0 = n; (s) ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s) ⊦ (⌜a '⌝ + σ)[n + 1] = σ[n]; (s) a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ a + x = a ' + x; (s) ⊦ #(a ' + x) = (# x)+1; (s) ⊦ m +1 = m + 1; (s) a: ⊦ (x + y) + z = x + y + z; from specification list ⊦ σ1 ⊑ σ1 + σ2; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream ⊦ ext !([]) = []; (s) ⊦ σ.take(0) = []; (s) ⊦ ⌜[]⌝ = []; (s) ⊦ (⌜a '⌝ + σ)[0] = a; (s) ⊦ # [] = 0; (s) ⊦ σ.drop(0) = σ; (s) ⊦ [] + σ = σ; (s)

Proof step 47 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), paf(0) = cren(ca0), ren(a0) = cren(ca0), cext(ca0) ≠ None, ext(a0) ≠ None, pcsf ≠ (s0, cs0) ' + (λ n. pcsf(n + 1)), cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ , fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s0, cs0) ' + (λ n. pcsf(n + 1)), λ n. paf(n + 1)) → πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ ) = ⌜ca0 '⌝ + πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Proof step 48:
⊦ x + nf = (λ n. (n < # x ⊃ x[n];nf(n - # x)))
Proof step 49:
(s0, cs0) = pcsf(0), paf(0) = cren(ca0), ren(a0) = cren(ca0), cext(ca0) ≠ None, ext(a0) ≠ None, pcsf ≠ (λ n. (n < # (s0, cs0) ' ⊃ (s0, cs0) '[n];pcsf((n - # (s0, cs0) ') + 1))), cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ , fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren))) (λ n. (n < # (s0, cs0) ' ⊃ (s0, cs0) '[n];pcsf((n - # (s0, cs0) ') + 1)), λ n. paf(n + 1)) → πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ ) = ⌜ca0 '⌝ + πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ) ⊦

Rule argument

spec: stream, name:add-list-fun-def, seq: ⊦ x + nf = (λ n. (n < # x ⊃ x[n];nf(n - # x))), subst:[x, nf] → [(s0, cs0) ', λ n. pcsf(n + 1)]; ['a] → [('s, 'cs)], <all paths>

Additional information

Used terms: (s0, cs0) ', λ n. pcsf(n + 1)

Proof step 48 from proof repls-mon (previous step) (back to tree)

⊦ x + nf = (λ n. (n < # x ⊃ x[n];nf(n - # x)))

A spec-lemma

Proof step 49 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), paf(0) = cren(ca0), ren(a0) = cren(ca0), cext(ca0) ≠ None, ext(a0) ≠ None, pcsf ≠ (λ n. (n < # (s0, cs0) ' ⊃ (s0, cs0) '[n];pcsf((n - # (s0, cs0) ') + 1))), cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ , fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren))) (λ n. (n < # (s0, cs0) ' ⊃ (s0, cs0) '[n];pcsf((n - # (s0, cs0) ') + 1)), λ n. paf(n + 1)) → πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ ) = ⌜ca0 '⌝ + πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 50:
(s0, cs0) = pcsf(0), paf(0) = cren(ca0), ren(a0) = cren(ca0), cext(ca0) ≠ None, ext(a0) ≠ None, pcsf(n) ≠ (n = 0 ⊃ (s0, cs0);pcsf((n - 1) + 1)), cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ , fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren))) (λ n0. (n0 = 0 ⊃ (s0, cs0);pcsf((n0 - 1) + 1)), λ n. paf(n + 1)) → πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ ) = ⌜ca0 '⌝ + πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ # a ' = 0 +1; (s) ⊦ a '[0] = a; (s) ⊦ m < 1 ↔ m = 0; (s)

Proof step 50 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), paf(0) = cren(ca0), ren(a0) = cren(ca0), cext(ca0) ≠ None, ext(a0) ≠ None, pcsf(n) ≠ (n = 0 ⊃ (s0, cs0);pcsf((n - 1) + 1)), cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ , fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren))) (λ n0. (n0 = 0 ⊃ (s0, cs0);pcsf((n0 - 1) + 1)), λ n. paf(n + 1)) → πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ ) = ⌜ca0 '⌝ + πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ) ⊦

User applied rule case distinction

And obtained the following new goals

Proof step 51:
(s0, cs0) = pcsf(0), paf(0) = cren(ca0), ren(a0) = cren(ca0), cext(ca0) ≠ None, ext(a0) ≠ None, n ≠ 0, pcsf(n) ≠ pcsf((n - 1) + 1), cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ , fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren))) (λ n0. (n0 = 0 ⊃ (s0, cs0);pcsf((n0 - 1) + 1)), λ n. paf(n + 1)) → πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ ) = ⌜ca0 '⌝ + πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ) ⊦

Rule argument

pos: left 6

Additional information

Proof step 51 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), paf(0) = cren(ca0), ren(a0) = cren(ca0), cext(ca0) ≠ None, ext(a0) ≠ None, n ≠ 0, pcsf(n) ≠ pcsf((n - 1) + 1), cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜(s, as) '⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ', cren(ca0) ', ⌜as '⌝ + aσ, aα)⌝ , fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren))) (λ n0. (n0 = 0 ⊃ (s0, cs0);pcsf((n0 - 1) + 1)), λ n. paf(n + 1)) → πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ ) = ⌜ca0 '⌝ + πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ) ⊦

Heuristic elimination applied rule apply elim lemma

And closed the goal!

Rule argument

spec: nat, name:elim-pred-c, seq:n ≠ 0 ⊦ m = n - 1 ↔ n = m + 1, subst:[n, m] → [n, n1]

Additional information

Used simplifier rules: n ≠ 0 ⊦ m = n - 1 ↔ n = m + 1; (elim) Used terms: n, n1

Proof step 52 from proof repls-mon (previous step) (back to tree)

frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf.take(n0 +1), paf.take(n0 +1), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf.take(n0 +1 + 1), paf.take(n0 +1 + 1), ⌜as '⌝ + aσ, aα)⌝ , ∀ astart, astep, aext, as, aσ, aα, start, cstart, step, cstep, ren, cren, ext, cext, s, cs, pcsf, paf, aren. ¬ ( frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα) ∧ fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf) ∧ nounsharedextR(cren, cext, ren) ∧ Πok(ext, cext, ren, cren) ∧ cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα) ∧ ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf.take(n0), paf.take(n0), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf.take(n0 + 1), paf.take(n0 + 1), ⌜as '⌝ + aσ, aα)⌝ ) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 53:
frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf.take(n0 + 1), paf.take(n0 + 1), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf.take(2 + n0), paf.take(2 + n0), ⌜as '⌝ + aσ, aα)⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Rule argument

Additional information

Used simplifier rules: a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic c: ⊦ m + n = n + m; from specification nat-basic ⊦ m +1 = m + 1; (s)

Proof step 53 from proof repls-mon (previous step) (back to tree)

frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf.take(n0 + 1), paf.take(n0 + 1), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf.take(2 + n0), paf.take(2 + n0), ⌜as '⌝ + aσ, aα)⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Proof step 54:
⊦ nf.take(n + 1) = nf(0) + (λ n. nf(n + 1)).take(n)
Proof step 55:
frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (pcsf(0) + (λ n. pcsf(n + 1)).take(n0)), paf.take(n0 + 1), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf.take(2 + n0), paf.take(2 + n0), ⌜as '⌝ + aσ, aα)⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Rule argument

spec: stream, name: to-succ-nf, seq: ⊦ nf.take(n + 1) = nf(0) + (λ n. nf(n + 1)).take(n), subst:[nf, n] → [pcsf, n0]; ['a] → [('s, 'cs)], <all paths>

Additional information

Used terms: pcsf, n0

Proof step 54 from proof repls-mon (previous step) (back to tree)

⊦ nf.take(n + 1) = nf(0) + (λ n. nf(n + 1)).take(n)

A spec-lemma

Proof step 55 from proof repls-mon (previous step) (back to tree)

frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (pcsf(0) + (λ n. pcsf(n + 1)).take(n0)), paf.take(n0 + 1), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf.take(2 + n0), paf.take(2 + n0), ⌜as '⌝ + aσ, aα)⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 56:
frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf(0) ' + (λ n. pcsf(n + 1)).take(n0), paf.take(n0 + 1), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf.take(2 + n0), paf.take(2 + n0), ⌜as '⌝ + aσ, aα)⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list ⊦ a + x = a ' + x; (s)

Proof step 56 from proof repls-mon (previous step) (back to tree)

frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf(0) ' + (λ n. pcsf(n + 1)).take(n0), paf.take(n0 + 1), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf.take(2 + n0), paf.take(2 + n0), ⌜as '⌝ + aσ, aα)⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Proof step 57:
⊦ nf.take(n + 2) = nf(0) + (λ n. nf(n + 1)).take(n + 1)
Proof step 58:
frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf(0) ' + (λ n. pcsf(n + 1)).take(n0), paf.take(n0 + 1), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (pcsf(0) + (λ n. pcsf(n + 1)).take(n0 + 1)), paf.take(2 + n0), ⌜as '⌝ + aσ, aα)⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Rule argument

spec: stream, name: to-succ2-nf, seq: ⊦ nf.take(n + 2) = nf(0) + (λ n. nf(n + 1)).take(n + 1), subst:[nf, n] → [pcsf, n0]; ['a] → [('s, 'cs)], <all paths>

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic Used terms: pcsf, n0

Proof step 57 from proof repls-mon (previous step) (back to tree)

⊦ nf.take(n + 2) = nf(0) + (λ n. nf(n + 1)).take(n + 1)

A spec-lemma

Proof step 58 from proof repls-mon (previous step) (back to tree)

frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf(0) ' + (λ n. pcsf(n + 1)).take(n0), paf.take(n0 + 1), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (pcsf(0) + (λ n. pcsf(n + 1)).take(n0 + 1)), paf.take(2 + n0), ⌜as '⌝ + aσ, aα)⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 59:
frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf(0) ' + (λ n. pcsf(n + 1)).take(n0), paf.take(n0 + 1), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf(0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf.take(2 + n0), ⌜as '⌝ + aσ, aα)⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list ⊦ a + x = a ' + x; (s)

Proof step 59 from proof repls-mon (previous step) (back to tree)

frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf(0) ' + (λ n. pcsf(n + 1)).take(n0), paf.take(n0 + 1), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf(0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf.take(2 + n0), ⌜as '⌝ + aσ, aα)⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Proof step 60:
⊦ nf.take(n + 2) = nf(0) + (λ n. nf(n + 1)).take(n + 1)
Proof step 61:
frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf(0) ' + (λ n. pcsf(n + 1)).take(n0), paf.take(n0 + 1), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf(0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Rule argument

spec: stream, name: to-succ2-nf, seq: ⊦ nf.take(n + 2) = nf(0) + (λ n. nf(n + 1)).take(n + 1), subst:[nf, n] → [paf, n0]; ['a] → ['pa], <all paths>

Additional information

Used simplifier rules: c: ⊦ m + n = n + m; from specification nat-basic Used terms: paf, n0

Proof step 60 from proof repls-mon (previous step) (back to tree)

⊦ nf.take(n + 2) = nf(0) + (λ n. nf(n + 1)).take(n + 1)

A spec-lemma

Proof step 61 from proof repls-mon (previous step) (back to tree)

frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf(0) ' + (λ n. pcsf(n + 1)).take(n0), paf.take(n0 + 1), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf(0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 62:
frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf(0) ' + (λ n. pcsf(n + 1)).take(n0), paf.take(n0 + 1), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf(0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ a + x = a ' + x; (s)

Proof step 62 from proof repls-mon (previous step) (back to tree)

frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf(0) ' + (λ n. pcsf(n + 1)).take(n0), paf.take(n0 + 1), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf(0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Proof step 63:
⊦ nf.take(n + 1) = nf(0) + (λ n. nf(n + 1)).take(n)
Proof step 64:
frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf(0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf(0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Rule argument

spec: stream, name: to-succ-nf, seq: ⊦ nf.take(n + 1) = nf(0) + (λ n. nf(n + 1)).take(n), subst:[nf, n] → [paf, n0]; ['a] → ['pa], <all paths>

Additional information

Used terms: paf, n0

Proof step 63 from proof repls-mon (previous step) (back to tree)

⊦ nf.take(n + 1) = nf(0) + (λ n. nf(n + 1)).take(n)

A spec-lemma

Proof step 64 from proof repls-mon (previous step) (back to tree)

frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf(0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf(0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 65:
frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf(0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf(0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ a + x = a ' + x; (s)

Proof step 65 from proof repls-mon (previous step) (back to tree)

frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf(0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf(0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

User applied rule structural induction

And obtained the following new goals

Proof step 66:
(s0, cs0) = pcsf(0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf(0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf(0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Rule argument

term: pcsf(0)

Additional information

Proof step 66 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf(0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + pcsf(0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 67:
(s0, cs0) = pcsf(0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Rule argument

Additional information

Proof step 67 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜pcsf⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Proof step 68:
⊦ ⌜nf⌝ = nf(0) + ⌜λ n. nf(n + 1)⌝
Proof step 69:
(s0, cs0) = pcsf(0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + (pcsf(0) + ⌜λ n. pcsf(n + 1)⌝ ), ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Rule argument

spec: stream, name: intrace-expand, seq: ⊦ ⌜nf⌝ = nf(0) + ⌜λ n. nf(n + 1)⌝ , subst:[nf] → [pcsf]; ['a] → [('s, 'cs)], <all paths>

Additional information

Used terms: pcsf

Proof step 68 from proof repls-mon (previous step) (back to tree)

⊦ ⌜nf⌝ = nf(0) + ⌜λ n. nf(n + 1)⌝

A spec-lemma

Proof step 69 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + (pcsf(0) + ⌜λ n. pcsf(n + 1)⌝ ), ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 70:
(s0, cs0) = pcsf(0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Rule argument

Additional information

Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream ⊦ a + σ = ⌜a '⌝ + σ; (s)

Proof step 70 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜paf⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Proof step 71:
⊦ ⌜nf⌝ = nf(0) + ⌜λ n. nf(n + 1)⌝
Proof step 72:
(s0, cs0) = pcsf(0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , paf(0) + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Rule argument

spec: stream, name: intrace-expand, seq: ⊦ ⌜nf⌝ = nf(0) + ⌜λ n. nf(n + 1)⌝ , subst:[nf] → [paf]; ['a] → ['pa], <all paths>

Additional information

Used terms: paf

Proof step 71 from proof repls-mon (previous step) (back to tree)

⊦ ⌜nf⌝ = nf(0) + ⌜λ n. nf(n + 1)⌝

A spec-lemma

Proof step 72 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , paf(0) + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 73:
(s0, cs0) = pcsf(0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜paf(0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ a + σ = ⌜a '⌝ + σ; (s)

Proof step 73 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s, cs) ' + pcsf, paf), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜paf(0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Proof step 74:
⊦ fragω(IOAut(start, step, ext))(s ' + sf, af) ↔ step(s, af(0), sf(0)) ∧ fragω(IOAut(start, step, ext))(sf, λ n. af(n + 1))
Proof step 75:
(s0, cs0) = pcsf(0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Π(step, cstep, ren, cren, ext, cext)((s, cs), paf(0), pcsf(0)), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜paf(0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Rule argument

spec: IOtrace, name:inffrag-rec1, seq:⊦ fragω(IOAut(start, step, ext))(s ' + sf, af) ↔ step(s, af(0), sf(0)) ∧ fragω(IOAut(start, step, ext))(sf, λ n. af(n + 1)), subst:[step, s, start, sf, ext, af] → [Π(step, cstep, ren, cren, ext, cext), (s, cs), Π(start, cstart), pcsf, Π(ext, cext, ren, cren), paf]; ['s, 'a, 'e] → [('s, 'cs), 'pa, 'e], <all paths>

Additional information

Used terms: (s, cs), Π(ext, cext, ren, cren), Π(start, cstart), pcsf, paf, Π(step, cstep, ren, cren, ext, cext)

Proof step 74 from proof repls-mon (previous step) (back to tree)

⊦ fragω(IOAut(start, step, ext))(s ' + sf, af) ↔ step(s, af(0), sf(0)) ∧ fragω(IOAut(start, step, ext))(sf, λ n. af(n + 1))

A spec-lemma

Proof step 75 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Π(step, cstep, ren, cren, ext, cext)((s, cs), paf(0), pcsf(0)), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜paf(0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 76:
(s0, cs0) = pcsf(0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Π(step, cstep, ren, cren, ext, cext)((s, cs), paf(0), (s0, cs0)), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜paf(0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Rule argument

Additional information

Proof step 76 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Π(step, cstep, ren, cren, ext, cext)((s, cs), paf(0), (s0, cs0)), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜paf(0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Proof step 77:
⊦ Π(lstep, rstep, lren, rren, lext, rext)((ls, rs), pa, (ls0, rs0)) ↔ rs = rs0 ∧ (∃ la. lstep(ls, la, ls0) ∧ pa = lren(la) ∧ ¬ cod(rren)(pa)) ∨ ls = ls0 ∧ (∃ ra. rstep(rs, ra, rs0) ∧ pa = rren(ra) ∧ ¬ cod(lren)(pa)) ∨ (∃ la, ra. lstep(ls, la, ls0) ∧ lext(la) ≠ None ∧ pa = lren(la) ∧ rstep(rs, ra, rs0) ∧ rext(ra) ≠ None ∧ pa = rren(ra))
Proof step 78:
(s0, cs0) = pcsf(0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜paf(0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ , cs = cs0 ∧ (∃ la. step(s, la, s0) ∧ paf(0) = ren(la) ∧ ¬ cod(cren)(paf(0))) ∨ s = s0 ∧ (∃ ra. cstep(cs, ra, cs0) ∧ paf(0) = cren(ra) ∧ ¬ cod(ren)(paf(0))) ∨ (∃ la, ra. step(s, la, s0) ∧ ext(la) ≠ None ∧ paf(0) = ren(la) ∧ cstep(cs, ra, cs0) ∧ cext(ra) ≠ None ∧ paf(0) = cren(ra)) ⊦

Rule argument

spec: product, name: lrstep-def, seq:⊦ Π(lstep, rstep, lren, rren, lext, rext)((ls, rs), pa, (ls0, rs0)) ↔ rs = rs0 ∧ (∃ la. lstep(ls, la, ls0) ∧ pa = lren(la) ∧ ¬ cod(rren)(pa)) ∨ ls = ls0 ∧ (∃ ra. rstep(rs, ra, rs0) ∧ pa = rren(ra) ∧ ¬ cod(lren)(pa)) ∨ (∃ la, ra. lstep(ls, la, ls0) ∧ lext(la) ≠ None ∧ pa = lren(la) ∧ rstep(rs, ra, rs0) ∧ rext(ra) ≠ None ∧ pa = rren(ra)), subst:[pa, ls0, rext, lstep, rs0, ls, rs, rren, lren, lext, rstep] → [paf(0), s0, cext, step, cs0, s, cs, cren, ren, ext, cstep]; ['ls, 'ra, 'la, 'pa, 'rs, 'e] → ['s, 'ca, 'a, 'pa, 'cs, 'e], <all paths>

Additional information

Used terms: cext, paf(0), cs, cstep, ren, ext, cren, cs0, step, s, s0

Proof step 77 from proof repls-mon (previous step) (back to tree)

⊦ Π(lstep, rstep, lren, rren, lext, rext)((ls, rs), pa, (ls0, rs0)) ↔ rs = rs0 ∧ (∃ la. lstep(ls, la, ls0) ∧ pa = lren(la) ∧ ¬ cod(rren)(pa)) ∨ ls = ls0 ∧ (∃ ra. rstep(rs, ra, rs0) ∧ pa = rren(ra) ∧ ¬ cod(lren)(pa)) ∨ (∃ la, ra. lstep(ls, la, ls0) ∧ lext(la) ≠ None ∧ pa = lren(la) ∧ rstep(rs, ra, rs0) ∧ rext(ra) ≠ None ∧ pa = rren(ra))

A spec-lemma

Proof step 78 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜paf(0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ , cs = cs0 ∧ (∃ la. step(s, la, s0) ∧ paf(0) = ren(la) ∧ ¬ cod(cren)(paf(0))) ∨ s = s0 ∧ (∃ ra. cstep(cs, ra, cs0) ∧ paf(0) = cren(ra) ∧ ¬ cod(ren)(paf(0))) ∨ (∃ la, ra. step(s, la, s0) ∧ ext(la) ≠ None ∧ paf(0) = ren(la) ∧ cstep(cs, ra, cs0) ∧ cext(ra) ≠ None ∧ paf(0) = cren(ra)) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 79:
(s0, cs0) = pcsf(0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜paf(0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ , cs = cs0 ∧ step(s, a, s0) ∧ paf(0) = ren(a) ∧ ¬ cod(cren)(paf(0)) ∨ s = s0 ∧ cstep(cs, ca, cs0) ∧ paf(0) = cren(ca) ∧ ¬ cod(ren)(paf(0)) ∨ step(s, a0, s0) ∧ ext(a0) ≠ None ∧ paf(0) = ren(a0) ∧ cstep(cs, ca0, cs0) ∧ cext(ca0) ≠ None ∧ paf(0) = cren(ca0) ⊦

Rule argument

Additional information

Proof step 79 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜paf(0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ , cs = cs0 ∧ step(s, a, s0) ∧ paf(0) = ren(a) ∧ ¬ cod(cren)(paf(0)) ∨ s = s0 ∧ cstep(cs, ca, cs0) ∧ paf(0) = cren(ca) ∧ ¬ cod(ren)(paf(0)) ∨ step(s, a0, s0) ∧ ext(a0) ≠ None ∧ paf(0) = ren(a0) ∧ cstep(cs, ca0, cs0) ∧ cext(ca0) ≠ None ∧ paf(0) = cren(ca0) ⊦

User applied rule cut formula

And obtained the following new goals

Proof step 80:
(s0, cs0) = pcsf(0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜paf(0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ , cs = cs0 ∧ step(s, a, s0) ∧ paf(0) = ren(a) ∧ ¬ cod(cren)(paf(0)) ∨ s = s0 ∧ cstep(cs, ca, cs0) ∧ paf(0) = cren(ca) ∧ ¬ cod(ren)(paf(0)) ∨ step(s, a0, s0) ∧ ext(a0) ≠ None ∧ paf(0) = ren(a0) ∧ cstep(cs, ca0, cs0) ∧ cext(ca0) ≠ None ∧ paf(0) = cren(ca0) ⊦
Proof step 133:
(s0, cs0) = pcsf(0), pcsf ≠ (s0, cs0) ' + (λ n. pcsf(n + 1)), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜paf(0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ , cs = cs0 ∧ step(s, a, s0) ∧ paf(0) = ren(a) ∧ ¬ cod(cren)(paf(0)) ∨ s = s0 ∧ cstep(cs, ca, cs0) ∧ paf(0) = cren(ca) ∧ ¬ cod(ren)(paf(0)) ∨ step(s, a0, s0) ∧ ext(a0) ≠ None ∧ paf(0) = ren(a0) ∧ cstep(cs, ca0, cs0) ∧ cext(ca0) ≠ None ∧ paf(0) = cren(ca0) ⊦

Rule argument

fma: pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1))

Additional information

Used formulas: pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1))

Proof step 80 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜paf(0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ , cs = cs0 ∧ step(s, a, s0) ∧ paf(0) = ren(a) ∧ ¬ cod(cren)(paf(0)) ∨ s = s0 ∧ cstep(cs, ca, cs0) ∧ paf(0) = cren(ca) ∧ ¬ cod(ren)(paf(0)) ∨ step(s, a0, s0) ∧ ext(a0) ≠ None ∧ paf(0) = ren(a0) ∧ cstep(cs, ca0, cs0) ∧ cext(ca0) ≠ None ∧ paf(0) = cren(ca0) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 81:
(s0, cs0) = pcsf(0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜paf(0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ , cs = cs0 ∧ step(s, a, s0) ∧ paf(0) = ren(a) ∧ ¬ cod(cren)(paf(0)) ∨ s = s0 ∧ cstep(cs, ca, cs0) ∧ paf(0) = cren(ca) ∧ ¬ cod(ren)(paf(0)) ∨ step(s, a0, s0) ∧ ext(a0) ≠ None ∧ paf(0) = ren(a0) ∧ cstep(cs, ca0, cs0) ∧ cext(ca0) ≠ None ∧ paf(0) = cren(ca0) ⊦

Rule argument

Additional information

Proof step 81 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜paf(0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ , cs = cs0 ∧ step(s, a, s0) ∧ paf(0) = ren(a) ∧ ¬ cod(cren)(paf(0)) ∨ s = s0 ∧ cstep(cs, ca, cs0) ∧ paf(0) = cren(ca) ∧ ¬ cod(ren)(paf(0)) ∨ step(s, a0, s0) ∧ ext(a0) ≠ None ∧ paf(0) = ren(a0) ∧ cstep(cs, ca0, cs0) ∧ cext(ca0) ≠ None ∧ paf(0) = cren(ca0) ⊦

User applied rule case distinction

And obtained the following new goals

Proof step 82:
(s0, cs0) = pcsf(0), cs = cs0, paf(0) = ren(a), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜paf(0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ cod(cren)(paf(0)), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦
Proof step 87:
(s0, cs0) = pcsf(0), paf(0) = cren(ca), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), s = s0, cstep(cs, ca, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜paf(0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ cod(ren)(paf(0)), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦
Proof step 94:
(s0, cs0) = pcsf(0), paf(0) = ren(a0), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜paf(0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Rule argument

pos: left 10

Additional information

Proof step 82 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), cs = cs0, paf(0) = ren(a), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜paf(0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ cod(cren)(paf(0)), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 83:
(s0, cs0) = pcsf(0), paf(0) = ren(a), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs0) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜ren(a) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ cod(cren)(ren(a)), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα)⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Rule argument

Additional information

Used simplifier rules: repls-rec-addS: ⊦ step(s, a, s0) ∧ ¬ cod(cren)(ren(a)) → repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs) ' + pcsl, ren(a) ' + pal, ⌜as '⌝ + aσ, aα) = (s, as) ' + repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs) ' + pcsl, pal, ⌜as '⌝ + aσ, aα); append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream ⊦ ⌜x⌝ + σ1 ⊑ ⌜x⌝ + σ2 ↔ σ1 ⊑ σ2; (s) a: ⊦ (x + y) + z = x + y + z; from specification list ⊦ ⌜x + y⌝ = ⌜x⌝ + ⌜y⌝ ; (s)

Proof step 83 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), paf(0) = ren(a), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs0) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜ren(a) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ cod(cren)(ren(a)), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα)⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

User applied rule all left

And obtained the following new goals

Proof step 84:
(s0, cs0) = pcsf(0), paf(0) = ren(a), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs0) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜ren(a) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ cod(cren)(ren(a)), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα)⌝ , ¬ frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα) ∨ ¬ fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s0, cs0) ' + (λ n. pcsf(n + 1)), λ n. paf(n + 1)) ∨ ¬ nounsharedextR(cren, cext, ren) ∨ ¬ Πok(ext, cext, ren, cren) ∨ ¬ cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα) ∨ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ ⊦

Rule argument

pos: left 12 terms: astart, astep, aext, as, aσ, aα, start, cstart, step, cstep, ren, cren, ext, cext, s0, cs0, λ n. pcsf(n + 1), λ n. paf(n + 1), aren abort: F discard: T computed: T

Additional information

Used terms: astart, astep, aext, as, aσ, aα, start, cstart, step, cstep, ren, cren, ext, cext, s0, cs0, λ n. pcsf(n + 1), λ n. paf(n + 1), aren

Proof step 84 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), paf(0) = ren(a), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs0) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜ren(a) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ cod(cren)(ren(a)), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα)⌝ , ¬ frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα) ∨ ¬ fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s0, cs0) ' + (λ n. pcsf(n + 1)), λ n. paf(n + 1)) ∨ ¬ nounsharedextR(cren, cext, ren) ∨ ¬ Πok(ext, cext, ren, cren) ∨ ¬ cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα) ∨ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 85:
(s0, cs0) = pcsf(0), paf(0) = ren(a), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs0) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜ren(a) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ cod(cren)(ren(a)), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα)⌝ , ¬ cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα) ⊦

Rule argument

Additional information

Proof step 85 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), paf(0) = ren(a), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs0) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜ren(a) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ cod(cren)(ren(a)), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα)⌝ , ¬ cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα) ⊦

User applied rule apply lemma

And obtained the following new goals

Proof step 86:
⊦ Πok(lext, rext, lren, rren) ∧ lstep(ls, la, ls0) ∧ ¬ cod(rren)(lren(la)) ∧ fragω(IOAut(Π(lstart, rstart), Π(lstep, rstep, lren, rren, lext, rext), Π(lext, rext, lren, rren)))((ls0, rs) ' + psf, paf) → πra(lstep, rstep, lren, rren, ⌜(ls, rs) '⌝ + ⌜(ls0, rs) '⌝ + ⌜psf⌝ , lren(la) + ⌜paf⌝ ) = πra(lstep, rstep, lren, rren, ⌜(ls0, rs) '⌝ + ⌜psf⌝ , ⌜paf⌝ )

Rule argument

spec: project-right, name:projaction-infrec-skipL, seq:⊦ Πok(lext, rext, lren, rren) ∧ lstep(ls, la, ls0) ∧ ¬ cod(rren)(lren(la)) ∧ fragω (IOAut (Π(lstart, rstart), Π(lstep, rstep, lren, rren, lext, rext), Π(lext, rext, lren, rren))) ((ls0, rs) ' + psf, paf) → πra (lstep, rstep, lren, rren, ⌜(ls, rs) '⌝ + ⌜(ls0, rs) '⌝ + ⌜psf⌝ , lren(la) + ⌜paf⌝ ) = πra(lstep, rstep, lren, rren, ⌜(ls0, rs) '⌝ + ⌜psf⌝ , ⌜paf⌝ ), subst:[psf, lstart, ls0, rstart, rext, lstep, la, ls, rren, lren, lext, rstep, rs, paf] → [λ n. pcsf(n + 1), start, s0, cstart, cext, step, a, s, cren, ren, ext, cstep, cs0, λ n. paf(n + 1)]; ['ls, 'ra, 'la, 'pa, 'rs, 'e] → ['s, 'ca, 'a, 'pa, 'cs, 'e]

Additional information

Used simplifier rules: ⊦ a + σ = ⌜a '⌝ + σ; (s) Used terms: cext, cs0, cstart, cstep, λ n. pcsf(n + 1), ren, ext, cren, a, step, start, λ n. paf(n + 1), s, s0

Proof step 86 from proof repls-mon (previous step) (back to tree)

⊦ Πok(lext, rext, lren, rren) ∧ lstep(ls, la, ls0) ∧ ¬ cod(rren)(lren(la)) ∧ fragω(IOAut(Π(lstart, rstart), Π(lstep, rstep, lren, rren, lext, rext), Π(lext, rext, lren, rren)))((ls0, rs) ' + psf, paf) → πra(lstep, rstep, lren, rren, ⌜(ls, rs) '⌝ + ⌜(ls0, rs) '⌝ + ⌜psf⌝ , lren(la) + ⌜paf⌝ ) = πra(lstep, rstep, lren, rren, ⌜(ls0, rs) '⌝ + ⌜psf⌝ , ⌜paf⌝ )

A spec-lemma

Proof step 87 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), paf(0) = cren(ca), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), s = s0, cstep(cs, ca, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜paf(0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ cod(ren)(paf(0)), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 88:
(s0, cs0) = pcsf(0), paf(0) = cren(ca), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), cstep(cs, ca, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s0, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ cod(ren)(cren(ca)), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα)⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Rule argument

Additional information

Used simplifier rules: repls-rec-skip: ⊦ cstep(cs, ca, cs0) ∧ ¬ cod(ren)(cren(ca)) → repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s, cs0) ' + pcsl, cren(ca) ' + pal, ⌜as '⌝ + aσ, aα) = repls (step, cstep, cren, ren, aren, cext, aext, (s, cs0) ' + pcsl, pal, ⌜as '⌝ + aσ, aα); a: ⊦ (x + y) + z = x + y + z; from specification list append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream

Proof step 88 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), paf(0) = cren(ca), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), cstep(cs, ca, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s0, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ cod(ren)(cren(ca)), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα)⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

User applied rule all left

And obtained the following new goals

Proof step 89:
(s0, cs0) = pcsf(0), paf(0) = cren(ca), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), cstep(cs, ca, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s0, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ cod(ren)(cren(ca)), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα)⌝ , ¬ frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα) ∨ ¬ fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s0, cs0) ' + (λ n. pcsf(n + 1)), λ n. paf(n + 1)) ∨ ¬ nounsharedextR(cren, cext, ren) ∨ ¬ Πok(ext, cext, ren, cren) ∨ ¬ cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα) ∨ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ ⊦

Rule argument

pos: left 12 terms: astart, astep, aext, as, aσ, aα, start, cstart, step, cstep, ren, cren, ext, cext, s0, cs0, λ n. pcsf(n + 1), λ n. paf(n + 1), aren abort: F discard: T computed: T

Additional information

Used terms: astart, astep, aext, as, aσ, aα, start, cstart, step, cstep, ren, cren, ext, cext, s0, cs0, λ n. pcsf(n + 1), λ n. paf(n + 1), aren

Proof step 89 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), paf(0) = cren(ca), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), cstep(cs, ca, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s0, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ cod(ren)(cren(ca)), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα)⌝ , ¬ frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα) ∨ ¬ fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s0, cs0) ' + (λ n. pcsf(n + 1)), λ n. paf(n + 1)) ∨ ¬ nounsharedextR(cren, cext, ren) ∨ ¬ Πok(ext, cext, ren, cren) ∨ ¬ cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα) ∨ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 90:
(s0, cs0) = pcsf(0), paf(0) = cren(ca), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), cstep(cs, ca, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s0, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ cod(ren)(cren(ca)), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα)⌝ , ¬ cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα) ⊦

Rule argument

Additional information

Proof step 90 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), paf(0) = cren(ca), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), cstep(cs, ca, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s0, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ cod(ren)(cren(ca)), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα)⌝ , ¬ cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα) ⊦

User applied rule apply lemma

And obtained the following new goals

Proof step 91:
⊦ Πok(lext, rext, lren, rren) ∧ fragω(IOAut(Π(lstart, rstart), Π(lstep, rstep, lren, rren, lext, rext), Π(lext, rext, lren, rren)))((ls, rs0) ' + psf, paf) ∧ rstep(rs, ra, rs0) ∧ ¬ cod(lren)(rren(ra)) → πra(lstep, rstep, lren, rren, ⌜(ls, rs) '⌝ + ⌜(ls, rs0) '⌝ + ⌜psf⌝ , rren(ra) + ⌜paf⌝ ) = ⌜ra '⌝ + πra(lstep, rstep, lren, rren, (ls, rs0) + ⌜psf⌝ , ⌜paf⌝ )
Proof step 92:
(s0, cs0) = pcsf(0), paf(0) = cren(ca), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), cstep(cs, ca, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s0, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ cod(ren)(cren(ca)), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα)⌝ , ¬ cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), Πok(ext, cext, ren, cren) ∧ fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s0, cs0) ' + (λ n. pcsf(n + 1)), λ n. paf(n + 1)) ∧ cstep(cs, ca, cs0) ∧ ¬ cod(ren)(cren(ca)) → πra(step, cstep, ren, cren, ⌜(s0, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , cren(ca) + ⌜λ n. paf(n + 1)⌝ ) = ⌜ca '⌝ + πra(step, cstep, ren, cren, (s0, cs0) + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ) ⊦

Rule argument

spec: project-right, name:projaction-infrec-addR, seq:⊦ Πok(lext, rext, lren, rren) ∧ fragω (IOAut (Π(lstart, rstart), Π(lstep, rstep, lren, rren, lext, rext), Π(lext, rext, lren, rren))) ((ls, rs0) ' + psf, paf) ∧ rstep(rs, ra, rs0) ∧ ¬ cod(lren)(rren(ra)) → πra (lstep, rstep, lren, rren, ⌜(ls, rs) '⌝ + ⌜(ls, rs0) '⌝ + ⌜psf⌝ , rren(ra) + ⌜paf⌝ ) = ⌜ra '⌝ + πra(lstep, rstep, lren, rren, (ls, rs0) + ⌜psf⌝ , ⌜paf⌝ ), subst:[psf, lstart, rstart, rext, lstep, rs0, ra, ls, rren, lren, lext, rstep, rs, paf] → [λ n. pcsf(n + 1), start, cstart, cext, step, cs0, ca, s0, cren, ren, ext, cstep, cs, λ n. paf(n + 1)]; ['ls, 'ra, 'la, 'pa, 'rs, 'e] → ['s, 'ca, 'a, 'pa, 'cs, 'e]

Additional information

Used terms: cext, cs, cstart, cstep, λ n. pcsf(n + 1), ca, ren, ext, cren, cs0, step, start, λ n. paf(n + 1), s0

Proof step 91 from proof repls-mon (previous step) (back to tree)

⊦ Πok(lext, rext, lren, rren) ∧ fragω(IOAut(Π(lstart, rstart), Π(lstep, rstep, lren, rren, lext, rext), Π(lext, rext, lren, rren)))((ls, rs0) ' + psf, paf) ∧ rstep(rs, ra, rs0) ∧ ¬ cod(lren)(rren(ra)) → πra(lstep, rstep, lren, rren, ⌜(ls, rs) '⌝ + ⌜(ls, rs0) '⌝ + ⌜psf⌝ , rren(ra) + ⌜paf⌝ ) = ⌜ra '⌝ + πra(lstep, rstep, lren, rren, (ls, rs0) + ⌜psf⌝ , ⌜paf⌝ )

A spec-lemma

Proof step 92 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), paf(0) = cren(ca), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), cstep(cs, ca, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s0, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ cod(ren)(cren(ca)), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα)⌝ , ¬ cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), Πok(ext, cext, ren, cren) ∧ fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s0, cs0) ' + (λ n. pcsf(n + 1)), λ n. paf(n + 1)) ∧ cstep(cs, ca, cs0) ∧ ¬ cod(ren)(cren(ca)) → πra(step, cstep, ren, cren, ⌜(s0, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , cren(ca) + ⌜λ n. paf(n + 1)⌝ ) = ⌜ca '⌝ + πra(step, cstep, ren, cren, (s0, cs0) + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 93:
(s0, cs0) = pcsf(0), paf(0) = cren(ca), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), πra(step, cstep, ren, cren, ⌜(s0, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca) '⌝ + ⌜λ n. paf(n + 1)⌝ ) = ⌜ca '⌝ + πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ), cstep(cs, ca, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s0, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ cod(ren)(cren(ca)), ¬ cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα)⌝ ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ a + σ = ⌜a '⌝ + σ; (s)

Proof step 93 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), paf(0) = cren(ca), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), πra(step, cstep, ren, cren, ⌜(s0, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca) '⌝ + ⌜λ n. paf(n + 1)⌝ ) = ⌜ca '⌝ + πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ), cstep(cs, ca, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s0, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ cod(ren)(cren(ca)), ¬ cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα)⌝ ⊑ ⌜repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα)⌝ ⊦

User applied rule subst equation

And closed the goal!

Rule argument

pos: left 4, flags: discard

Additional information

Used simplifier rules: nounsharedextR-notcodren-internal: ⊦ ¬ cod(ren)(cren(ca)) ∧ nounsharedextR(cren, cext, ren) → (cext(ca) = None ↔ true); ⊦ ext !(⌜a '⌝ + α) = ext(a) + ext !(α); (s) ⊦ oe + β = (oe = None ⊃ [];⌜oe.get '⌝ ) + β; (s) ⊦ [] + σ = σ; (s) append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream

Proof step 94 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), paf(0) = ren(a0), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜paf(0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 95:
(s0, cs0) = pcsf(0), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), cren(ca0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Rule argument

Additional information

Proof step 95 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), cren(ca0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

User applied rule apply lemma

And obtained the following new goals

Proof step 96:
pa = rren(ra) ⊦ Πok(lext, rext, lren, rren) ∧ fragω(IOAut(Π(lstart, rstart), Π(lstep, rstep, lren, rren, lext, rext), Π(lext, rext, lren, rren)))((ls0, rs0) ' + psf, paf) ∧ lstep(ls, la, ls0) ∧ rstep(rs, ra, rs0) ∧ lren(la) = rren(ra) → πra(lstep, rstep, lren, rren, ⌜(ls, rs) '⌝ + ⌜(ls0, rs0) '⌝ + ⌜psf⌝ , pa + ⌜paf⌝ ) = ⌜ra '⌝ + πra(lstep, rstep, lren, rren, ⌜(ls0, rs0) '⌝ + ⌜psf⌝ , ⌜paf⌝ )
Proof step 97:
(s0, cs0) = pcsf(0), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), cren(ca0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , Πok(ext, cext, ren, cren) ∧ fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s0, cs0) ' + (λ n. pcsf(n + 1)), λ n. paf(n + 1)) ∧ step(s, a0, s0) ∧ cstep(cs, ca0, cs0) ∧ ren(a0) = cren(ca0) → πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ren(a0) + ⌜λ n. paf(n + 1)⌝ ) = ⌜ca0 '⌝ + πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ), ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Rule argument

spec: project-right, name:projaction-infrec-addboth, seq:pa = rren(ra) ⊦ Πok(lext, rext, lren, rren) ∧ fragω (IOAut (Π(lstart, rstart), Π(lstep, rstep, lren, rren, lext, rext), Π(lext, rext, lren, rren))) ((ls0, rs0) ' + psf, paf) ∧ lstep(ls, la, ls0) ∧ rstep(rs, ra, rs0) ∧ lren(la) = rren(ra) → πra (lstep, rstep, lren, rren, ⌜(ls, rs) '⌝ + ⌜(ls0, rs0) '⌝ + ⌜psf⌝ , pa + ⌜paf⌝ ) = ⌜ra '⌝ + πra(lstep, rstep, lren, rren, ⌜(ls0, rs0) '⌝ + ⌜psf⌝ , ⌜paf⌝ ), subst:[psf, lstart, pa, ls0, rstart, rext, lstep, ra, ls, rren, rs0, la, lren, lext, rstep, rs, paf] → [λ n. pcsf(n + 1), start, ren(a0), s0, cstart, cext, step, ca0, s, cren, cs0, a0, ren, ext, cstep, cs, λ n. paf(n + 1)]; ['ls, 'ra, 'la, 'pa, 'rs, 'e] → ['s, 'ca, 'a, 'pa, 'cs, 'e]

Additional information

Used terms: cext, ren(a0), cs, cstart, cstep, λ n. pcsf(n + 1), ca0, ren, ext, cren, a0, cs0, step, start, λ n. paf(n + 1), s, s0

Proof step 96 from proof repls-mon (previous step) (back to tree)

pa = rren(ra) ⊦ Πok(lext, rext, lren, rren) ∧ fragω(IOAut(Π(lstart, rstart), Π(lstep, rstep, lren, rren, lext, rext), Π(lext, rext, lren, rren)))((ls0, rs0) ' + psf, paf) ∧ lstep(ls, la, ls0) ∧ rstep(rs, ra, rs0) ∧ lren(la) = rren(ra) → πra(lstep, rstep, lren, rren, ⌜(ls, rs) '⌝ + ⌜(ls0, rs0) '⌝ + ⌜psf⌝ , pa + ⌜paf⌝ ) = ⌜ra '⌝ + πra(lstep, rstep, lren, rren, ⌜(ls0, rs0) '⌝ + ⌜psf⌝ , ⌜paf⌝ )

A spec-lemma

Proof step 97 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), cren(ca0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , Πok(ext, cext, ren, cren) ∧ fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s0, cs0) ' + (λ n. pcsf(n + 1)), λ n. paf(n + 1)) ∧ step(s, a0, s0) ∧ cstep(cs, ca0, cs0) ∧ ren(a0) = cren(ca0) → πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ren(a0) + ⌜λ n. paf(n + 1)⌝ ) = ⌜ca0 '⌝ + πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ), ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 98:
(s0, cs0) = pcsf(0), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ ) = ⌜ca0 '⌝ + πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), cren(ca0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ a + σ = ⌜a '⌝ + σ; (s)

Proof step 98 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ ) = ⌜ca0 '⌝ + πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜cren(ca0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), cren(ca0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

User applied rule subst equation

And obtained the following new goals

Proof step 99:
(s0, cs0) = pcsf(0), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(⌜ca0 '⌝ + πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), cren(ca0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Rule argument

pos: left 5, flags: discard

Additional information

Proof step 99 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), cext !(⌜ca0 '⌝ + πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), cren(ca0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 100:
(s0, cs0) = pcsf(0), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ⌜cext(ca0).get '⌝ + cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), cren(ca0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Rule argument

Additional information

Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream ⊦ ext(a) ≠ None → ext !(⌜a '⌝ + α) = ⌜ext(a).get '⌝ + ext !(α); (s)

Proof step 100 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ⌜cext(ca0).get '⌝ + cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), cren(ca0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

User applied rule apply elim lemma

And obtained the following new goals

Proof step 101:
(s0, cs0) = pcsf(0), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ⌜e '⌝ + cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), cren(ca0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Rule argument

spec: option, name:elim-Some, seq: ⊦ opt ≠ None → (get = opt.get ↔ opt = Some(get)), subst:[opt, get] → [cext(ca0), e]; ['a] → ['e]

Additional information

Used simplifier rules: ⊦ opt ≠ None → (get = opt.get ↔ opt = Some(get)); (elim) Used terms: cext(ca0), e

Proof step 101 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), cext(ca0) ≠ None, ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ⌜e '⌝ + cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), cren(ca0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 102:
(s0, cs0) = pcsf(0), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ⌜e '⌝ + cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), cren(ca0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα), ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s1, cs1, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s1, cs1) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s1, cs1) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0) ⊑ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ Some(a) ≠ None; (s) ⊦ ⌜x⌝ ⊑ ⌜y⌝ ↔ x ⊑ y; (s)

Proof step 102 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ⌜e '⌝ + cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), cren(ca0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα), ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s1, cs1, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s1, cs1) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s1, cs1) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0) ⊑ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Proof step 103:
⊦ σ ⊑ σ0 ↔ (∃ σ1. σ + σ1 = σ0)
Proof step 104:
(s0, cs0) = pcsf(0), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), cren(ca0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα), ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s1, cs1, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s1, cs1) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s1, cs1) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0) ⊑ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0), ∃ σ1. (⌜e '⌝ + cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ))) + σ1 = aext !(aα) ⊦

Rule argument

spec: stream, name: prefix-def, seq: ⊦ σ ⊑ σ0 ↔ (∃ σ1. σ + σ1 = σ0), subst:[σ, σ0] → [ ⌜e '⌝ + cext ! (πra (step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )), aext !(aα)]; ['a] → ['e], <all paths>

Additional information

Used terms: ⌜e '⌝ + cext ! (πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )), aext !(aα)

Proof step 103 from proof repls-mon (previous step) (back to tree)

⊦ σ ⊑ σ0 ↔ (∃ σ1. σ + σ1 = σ0)

A spec-lemma

Proof step 104 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), cren(ca0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα), ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s1, cs1, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s1, cs1) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s1, cs1) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0) ⊑ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0), ∃ σ1. (⌜e '⌝ + cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ))) + σ1 = aext !(aα) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 105:
(s0, cs0) = pcsf(0), (⌜e '⌝ + cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ))) + β = aext !(aα), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), cren(ca0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα), ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s1, cs1, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s1, cs1) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s1, cs1) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0) ⊑ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0) ⊦

Rule argument

Additional information

Proof step 105 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), (⌜e '⌝ + cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ ))) + β = aext !(aα), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), cren(ca0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα), ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s1, cs1, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s1, cs1) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s1, cs1) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0) ⊑ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Proof step 106:
⊦ ext !(α) = ⌜e '⌝ + β ↔ (∃ al, a, α0. α = ⌜al⌝ + ⌜a '⌝ + α0 ∧ ext(a) = Some(e) ∧ ext !(⌜al⌝ ) = [] ∧ ext !(α0) = β)
Proof step 107:
(s0, cs0) = pcsf(0), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), cren(ca0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα), ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s1, cs1, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s1, cs1) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s1, cs1) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0) ⊑ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0), ∃ al, aa, α0. aα = ⌜al⌝ + ⌜aa '⌝ + α0 ∧ aext(aa) = Some(e) ∧ aext !(⌜al⌝ ) = [] ∧ aext !(α0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β ⊦

Rule argument

spec: remtau, name: remtau-split-one, seq:⊦ ext !(α) = ⌜e '⌝ + β ↔ (∃ al, a, α0. α = ⌜al⌝ + ⌜a '⌝ + α0 ∧ ext(a) = Some(e) ∧ ext !(⌜al⌝ ) = [] ∧ ext !(α0) = β), subst:[e, β, ext, α] → [e, cext ! (πra (step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, aext, aα]; ['e, 'a] → ['e, 'aa], <all paths>

Additional information

Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream Used terms: e, cext ! (πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, aext, aα

Proof step 106 from proof repls-mon (previous step) (back to tree)

⊦ ext !(α) = ⌜e '⌝ + β ↔ (∃ al, a, α0. α = ⌜al⌝ + ⌜a '⌝ + α0 ∧ ext(a) = Some(e) ∧ ext !(⌜al⌝ ) = [] ∧ ext !(α0) = β)

A spec-lemma

Proof step 107 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), cren(ca0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα), ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s1, cs1, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s1, cs1) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s1, cs1) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0) ⊑ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0), ∃ al, aa, α0. aα = ⌜al⌝ + ⌜aa '⌝ + α0 ∧ aext(aa) = Some(e) ∧ aext !(⌜al⌝ ) = [] ∧ aext !(α0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 108:
aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, aext !(aal) = [], (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), cren(ca0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s1, cs1, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s1, cs1) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s1, cs1) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0) ⊑ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ ⌜x⌝ = [] ↔ x = []; (s) ⊦ ext !(⌜al⌝ ) = ⌜ext !(al)⌝ ; (s)

Proof step 108 from proof repls-mon (previous step) (back to tree)

aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, aext !(aal) = [], (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), cren(ca0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s1, cs1, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s1, cs1) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s1, cs1) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0) ⊑ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0) ⊦

User applied rule apply lemma

And obtained the following new goals

Proof step 109:
⊦ step(s, a, s0) ∧ cstep(cs, ca, cs0) ∧ aext !(⌜aal⌝ ) = [] ∧ cext(ca) = aext(aa) ∧ cren(ca) = ren(a) ∧ n = # aal → repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + pcsl, ren(a) ' + pal, aσ, ⌜aal⌝ + ⌜aa '⌝ + aα) = lift(aσ.take(n), s) + (s, aσ[n]) ' + repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + pcsl, pal, aσ.drop(n + 1), aα)
Proof step 110:
aext !(aal) = [], aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), cren(ca0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), step(s, a0, s0) ∧ cstep(cs, ca0, cs0) ∧ aext !(⌜aal⌝ ) = [] ∧ cext(ca0) = aext(aa) ∧ cren(ca0) = ren(a0) ∧ # aal = # aal → repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), ren(a0) ' + (λ n. paf(n + 1)).take(n0), as + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0) = lift((as + aσ).take(# aal), s) + (s, (as + aσ)[# aal]) ' + repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), (as + aσ).drop(# aal + 1), aα0), ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s1, cs1, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s1, cs1) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s1, cs1) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0) ⊑ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0) ⊦

Rule argument

spec: <toplevel>, name:repls-rec-addboth, seq:⊦ step(s, a, s0) ∧ cstep(cs, ca, cs0) ∧ aext !(⌜aal⌝ ) = [] ∧ cext(ca) = aext(aa) ∧ cren(ca) = ren(a) ∧ n = # aal → repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + pcsl, ren(a) ' + pal, aσ, ⌜aal⌝ + ⌜aa '⌝ + aα) = lift(aσ.take(n), s) + (s, aσ[n]) ' + repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + pcsl, pal, aσ.drop(n + 1), aα), subst:[ca, a, aal, aa, aσ, cren, ren, n, cstep, aren, pcsl, aext, step, pal, cs, cext, s0, cs0, aα, s] → [ca0, a0, aal, aa, as + aσ, cren, ren, # aal, cstep, aren, (λ n. pcsf(n + 1)).take(n0), aext, step, (λ n. paf(n + 1)).take(n0), cs, cext, s0, cs0, aα0, s]; ['ca, 'cs, 'a, 'aa, 'pa, 'e, 's, 'as] → ['ca, 'cs, 'a, 'aa, 'pa, 'e, 's, 'as]

Additional information

Used terms: aren, ren, cstep, cext, aa, s, aext, aα0, ca0, a0, (λ n. paf(n + 1)).take(n0), cren, aal, (λ n. pcsf(n + 1)).take(n0), cs0, s0, cs, # aal, as + aσ, step

Proof step 109 from proof repls-mon (previous step) (back to tree)

⊦ step(s, a, s0) ∧ cstep(cs, ca, cs0) ∧ aext !(⌜aal⌝ ) = [] ∧ cext(ca) = aext(aa) ∧ cren(ca) = ren(a) ∧ n = # aal → repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + pcsl, ren(a) ' + pal, aσ, ⌜aal⌝ + ⌜aa '⌝ + aα) = lift(aσ.take(n), s) + (s, aσ[n]) ' + repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + pcsl, pal, aσ.drop(n + 1), aα)

Lemma repls-rec-addboth

Proof step 110 from proof repls-mon (previous step) (back to tree)

aext !(aal) = [], aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), cren(ca0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), step(s, a0, s0) ∧ cstep(cs, ca0, cs0) ∧ aext !(⌜aal⌝ ) = [] ∧ cext(ca0) = aext(aa) ∧ cren(ca0) = ren(a0) ∧ # aal = # aal → repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), ren(a0) ' + (λ n. paf(n + 1)).take(n0), as + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0) = lift((as + aσ).take(# aal), s) + (s, (as + aσ)[# aal]) ' + repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), (as + aσ).drop(# aal + 1), aα0), ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s1, cs1, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s1, cs1) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s1, cs1) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0) ⊑ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 111:
aext !(aal) = [], aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), cren(ca0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0) = lift((⌜as '⌝ + aσ).take(# aal), s) + (s, (⌜as '⌝ + aσ)[# aal]) ' + repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), aσ.drop(# aal), aα0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), cren(ca0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s1, cs1, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s1, cs1) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s1, cs1) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0) ⊑ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0) ⊦

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n + 0 = n; (s) ⊦ n ≠ 0 → (⌜a '⌝ + σ).drop((* n) + m) = σ.drop((n - 1) + m); (s) ⊦ a + σ = ⌜a '⌝ + σ; (s) ⊦ ⌜x⌝ = [] ↔ x = []; (s) ⊦ ext !(⌜al⌝ ) = ⌜ext !(al)⌝ ; (s)

Proof step 111 from proof repls-mon (previous step) (back to tree)

aext !(aal) = [], aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), cren(ca0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0) = lift((⌜as '⌝ + aσ).take(# aal), s) + (s, (⌜as '⌝ + aσ)[# aal]) ' + repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), aσ.drop(# aal), aα0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), cren(ca0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s1, cs1, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s1, cs1) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s1, cs1) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0) ⊑ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0) ⊦

User applied rule subst equation

And obtained the following new goals

Proof step 112:
aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, aext !(aal) = [], (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ lift((⌜as '⌝ + aσ).take(# aal), s) + (s, (⌜as '⌝ + aσ)[# aal]) ' + repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), aσ.drop(# aal), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s1, cs1, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s1, cs1) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s1, cs1) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0) ⊑ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0) ⊦

Rule argument

pos: left 9, flags: discard

Additional information

Proof step 112 from proof repls-mon (previous step) (back to tree)

aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, aext !(aal) = [], (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ lift((⌜as '⌝ + aσ).take(# aal), s) + (s, (⌜as '⌝ + aσ)[# aal]) ' + repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), aσ.drop(# aal), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s1, cs1, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s1, cs1) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s1, cs1) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0) ⊑ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 113:
aext !(aal) = [], aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ lift((⌜as '⌝ + aσ).take(# aal), s) + (s, (⌜as '⌝ + aσ)[# aal]) ' + repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), aσ.drop(# aal), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s1, cs1, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s1, cs1) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s1, cs1) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0) ⊑ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0) ⊦

Rule argument

Additional information

Proof step 113 from proof repls-mon (previous step) (back to tree)

aext !(aal) = [], aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ lift((⌜as '⌝ + aσ).take(# aal), s) + (s, (⌜as '⌝ + aσ)[# aal]) ' + repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), aσ.drop(# aal), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s1, cs1, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s1, cs1) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s1, cs1) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0) ⊑ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0) ⊦

User applied rule apply lemma

And obtained the following new goals

Proof step 114:
⊦ step(s, a, s0) ∧ cstep(cs, ca, cs0) ∧ aext !(⌜aal⌝ ) = [] ∧ cext(ca) = aext(aa) ∧ cren(ca) = ren(a) ∧ n = # aal → repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + pcsl, ren(a) ' + pal, aσ, ⌜aal⌝ + ⌜aa '⌝ + aα) = lift(aσ.take(n), s) + (s, aσ[n]) ' + repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + pcsl, pal, aσ.drop(n + 1), aα)
Proof step 115:
aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, aext !(aal) = [], (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ lift((⌜as '⌝ + aσ).take(# aal), s) + (s, (⌜as '⌝ + aσ)[# aal]) ' + repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), aσ.drop(# aal), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), step(s, a0, s0) ∧ cstep(cs, ca0, cs0) ∧ aext !(⌜aal⌝ ) = [] ∧ cext(ca0) = aext(aa) ∧ cren(ca0) = ren(a0) ∧ # aal = # aal → repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), ren(a0) ' + (λ n. paf(n + 1)).take(n0 + 1), as + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0) = lift((as + aσ).take(# aal), s) + (s, (as + aσ)[# aal]) ' + repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), (as + aσ).drop(# aal + 1), aα0), ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s1, cs1, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s1, cs1) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s1, cs1) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0) ⊑ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0) ⊦

Rule argument

spec: <toplevel>, name:repls-rec-addboth, seq:⊦ step(s, a, s0) ∧ cstep(cs, ca, cs0) ∧ aext !(⌜aal⌝ ) = [] ∧ cext(ca) = aext(aa) ∧ cren(ca) = ren(a) ∧ n = # aal → repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + pcsl, ren(a) ' + pal, aσ, ⌜aal⌝ + ⌜aa '⌝ + aα) = lift(aσ.take(n), s) + (s, aσ[n]) ' + repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + pcsl, pal, aσ.drop(n + 1), aα), subst:[ca, a, aal, aa, aσ, cren, ren, n, cstep, aren, pcsl, aext, step, pal, cs, cext, s0, cs0, aα, s] → [ca0, a0, aal, aa, as + aσ, cren, ren, # aal, cstep, aren, (λ n. pcsf(n + 1)).take(n0 + 1), aext, step, (λ n. paf(n + 1)).take(n0 + 1), cs, cext, s0, cs0, aα0, s]; ['ca, 'cs, 'a, 'aa, 'pa, 'e, 's, 'as] → ['ca, 'cs, 'a, 'aa, 'pa, 'e, 's, 'as]

Additional information

Used terms: aren, ren, cstep, cext, aa, s, aext, aα0, ca0, a0, (λ n. paf(n + 1)).take(n0 + 1), cren, aal, (λ n. pcsf(n + 1)).take(n0 + 1), cs0, s0, cs, # aal, as + aσ, step

Proof step 114 from proof repls-mon (previous step) (back to tree)

⊦ step(s, a, s0) ∧ cstep(cs, ca, cs0) ∧ aext !(⌜aal⌝ ) = [] ∧ cext(ca) = aext(aa) ∧ cren(ca) = ren(a) ∧ n = # aal → repls(step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + pcsl, ren(a) ' + pal, aσ, ⌜aal⌝ + ⌜aa '⌝ + aα) = lift(aσ.take(n), s) + (s, aσ[n]) ' + repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + pcsl, pal, aσ.drop(n + 1), aα)

Lemma repls-rec-addboth

Proof step 115 from proof repls-mon (previous step) (back to tree)

aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, aext !(aal) = [], (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ lift((⌜as '⌝ + aσ).take(# aal), s) + (s, (⌜as '⌝ + aσ)[# aal]) ' + repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), aσ.drop(# aal), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), step(s, a0, s0) ∧ cstep(cs, ca0, cs0) ∧ aext !(⌜aal⌝ ) = [] ∧ cext(ca0) = aext(aa) ∧ cren(ca0) = ren(a0) ∧ # aal = # aal → repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), ren(a0) ' + (λ n. paf(n + 1)).take(n0 + 1), as + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0) = lift((as + aσ).take(# aal), s) + (s, (as + aσ)[# aal]) ' + repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), (as + aσ).drop(# aal + 1), aα0), ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s1, cs1, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s1, cs1) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s1, cs1) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0) ⊑ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 116:
aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, aext !(aal) = [], (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0) = lift((⌜as '⌝ + aσ).take(# aal), s) + (s, (⌜as '⌝ + aσ)[# aal]) ' + repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), aσ.drop(# aal), aα0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ lift((⌜as '⌝ + aσ).take(# aal), s) + (s, (⌜as '⌝ + aσ)[# aal]) ' + repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), aσ.drop(# aal), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s1, cs1, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s1, cs1) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s1, cs1) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0) ⊑ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0) ⊦

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ n + 0 = n; (s) ⊦ n ≠ 0 → (⌜a '⌝ + σ).drop((* n) + m) = σ.drop((n - 1) + m); (s) ⊦ a + σ = ⌜a '⌝ + σ; (s) ⊦ ⌜x⌝ = [] ↔ x = []; (s) ⊦ ext !(⌜al⌝ ) = ⌜ext !(al)⌝ ; (s)

Proof step 116 from proof repls-mon (previous step) (back to tree)

aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, aext !(aal) = [], (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0) = lift((⌜as '⌝ + aσ).take(# aal), s) + (s, (⌜as '⌝ + aσ)[# aal]) ' + repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), aσ.drop(# aal), aα0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ lift((⌜as '⌝ + aσ).take(# aal), s) + (s, (⌜as '⌝ + aσ)[# aal]) ' + repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), aσ.drop(# aal), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), cren(ca0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s1, cs1, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s1, cs1) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s1, cs1) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0) ⊑ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0) ⊦

User applied rule subst equation

And obtained the following new goals

Proof step 117:
aext !(aal) = [], aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ lift((⌜as '⌝ + aσ).take(# aal), s) + (s, (⌜as '⌝ + aσ)[# aal]) ' + repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), aσ.drop(# aal), aα0) ⊑ lift((⌜as '⌝ + aσ).take(# aal), s) + (s, (⌜as '⌝ + aσ)[# aal]) ' + repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), aσ.drop(# aal), aα0), ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s1, cs1, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s1, cs1) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s1, cs1) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0) ⊑ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0) ⊦

Rule argument

pos: left 9, flags: discard

Additional information

Proof step 117 from proof repls-mon (previous step) (back to tree)

aext !(aal) = [], aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ lift((⌜as '⌝ + aσ).take(# aal), s) + (s, (⌜as '⌝ + aσ)[# aal]) ' + repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), aσ.drop(# aal), aα0) ⊑ lift((⌜as '⌝ + aσ).take(# aal), s) + (s, (⌜as '⌝ + aσ)[# aal]) ' + repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), aσ.drop(# aal), aα0), ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s1, cs1, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s1, cs1) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s1, cs1) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0) ⊑ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 118:
aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, aext !(aal) = [], (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), aσ.drop(# aal), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), aσ.drop(# aal), aα0), ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s1, cs1, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s1, cs1) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s1, cs1) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0) ⊑ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0) ⊦

Rule argument

Additional information

Used simplifier rules: a: ⊦ (x + y) + z = x + y + z; from specification list ⊦ a ' + x ⊑ b ' + y ↔ a = b ∧ x ⊑ y; (ws) ⊦ x + y ⊑ x + z ↔ y ⊑ z; (s)

Proof step 118 from proof repls-mon (previous step) (back to tree)

aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, aext !(aal) = [], (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), aσ.drop(# aal), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), aσ.drop(# aal), aα0), ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s1, cs1, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s1, cs1) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s1, cs1) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0) ⊑ repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s1, cs1) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0) ⊦

User applied rule all left

And obtained the following new goals

Proof step 119:
aext !(aal) = [], aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), aσ.drop(# aal), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), aσ.drop(# aal), aα0), ¬ frag(IOAut(astart, astep, aext))(⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ∨ ¬ fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s0, cs0) ' + (λ n. pcsf(n + 1)), λ n. paf(n + 1)) ∨ ¬ nounsharedextR(cren, cext, ren) ∨ ¬ Πok(ext, cext, ren, cren) ∨ ¬ cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα0) ∨ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊦

Rule argument

pos: left 17 terms: astart, astep, aext, aσ[# aal], aσ.drop(# aal + 1), aα0, start, cstart, step, cstep, ren, cren, ext, cext, s0, cs0, λ n. pcsf(n + 1), λ n. paf(n + 1), aren abort: F discard: T computed: F

Additional information

Used terms: astart, astep, aext, aσ[# aal], aσ.drop(# aal + 1), aα0, start, cstart, step, cstep, ren, cren, ext, cext, s0, cs0, λ n. pcsf(n + 1), λ n. paf(n + 1), aren

Proof step 119 from proof repls-mon (previous step) (back to tree)

aext !(aal) = [], aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), aσ.drop(# aal), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), aσ.drop(# aal), aα0), ¬ frag(IOAut(astart, astep, aext))(⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ∨ ¬ fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))((s0, cs0) ' + (λ n. pcsf(n + 1)), λ n. paf(n + 1)) ∨ ¬ nounsharedextR(cren, cext, ren) ∨ ¬ Πok(ext, cext, ren, cren) ∨ ¬ cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα0) ∨ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 120:
aext !(aal) = [], aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), aσ.drop(# aal), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), aσ.drop(# aal), aα0), ¬ frag(IOAut(astart, astep, aext))(⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ∨ ¬ cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα0) ∨ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊦

Rule argument

Additional information

Proof step 120 from proof repls-mon (previous step) (back to tree)

aext !(aal) = [], aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), aσ.drop(# aal), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), aσ.drop(# aal), aα0), ¬ frag(IOAut(astart, astep, aext))(⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ∨ ¬ cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα0) ∨ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊦

User applied rule apply lemma

And obtained the following new goals

Proof step 121:
⊦ frag(IOAut(start, step, ext))(σ, α) ∧ ¬ # α < ⌜n⌝ → (frag(IOAut(start, step, ext))(σ.drop(n), α.drop(n)) ↔ true)
Proof step 122:
aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, aext !(aal) = [], (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), aσ.drop(# aal), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), aσ.drop(# aal), aα0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0) ∧ ¬ #(⌜aal⌝ + ⌜aa '⌝ + aα0) < ⌜# aal + 1⌝ → (frag(IOAut(astart, astep, aext))((⌜as '⌝ + aσ).drop(# aal + 1), (⌜aal⌝ + ⌜aa '⌝ + aα0).drop(# aal + 1)) ↔ true), ¬ frag(IOAut(astart, astep, aext))(⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ∨ ¬ cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα0) ∨ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊦

Rule argument

spec: IOtrace, name:frag-from-1, seq:⊦ frag(IOAut(start, step, ext))(σ, α) ∧ ¬ # α < ⌜n⌝ → (frag(IOAut(start, step, ext))(σ.drop(n), α.drop(n)) ↔ true), subst:[step, α, start, ext, n, σ] → [astep, ⌜aal⌝ + ⌜aa '⌝ + aα0, astart, aext, # aal + 1, ⌜as '⌝ + aσ]; ['s, 'a, 'e] → ['as, 'aa, 'e]

Additional information

Used terms: aext, ⌜aal⌝ + ⌜aa '⌝ + aα0, astart, ⌜as '⌝ + aσ, # aal + 1, astep

Proof step 121 from proof repls-mon (previous step) (back to tree)

⊦ frag(IOAut(start, step, ext))(σ, α) ∧ ¬ # α < ⌜n⌝ → (frag(IOAut(start, step, ext))(σ.drop(n), α.drop(n)) ↔ true)

A spec-lemma

Proof step 122 from proof repls-mon (previous step) (back to tree)

aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, aext !(aal) = [], (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), aσ.drop(# aal), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), aσ.drop(# aal), aα0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0) ∧ ¬ #(⌜aal⌝ + ⌜aa '⌝ + aα0) < ⌜# aal + 1⌝ → (frag(IOAut(astart, astep, aext))((⌜as '⌝ + aσ).drop(# aal + 1), (⌜aal⌝ + ⌜aa '⌝ + aα0).drop(# aal + 1)) ↔ true), ¬ frag(IOAut(astart, astep, aext))(⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ∨ ¬ cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα0) ∨ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 123:
aext !(aal) = [], aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), frag(IOAut(astart, astep, aext))(aσ.drop(# aal), aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), aσ.drop(# aal), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), aσ.drop(# aal), aα0), ¬ frag(IOAut(astart, astep, aext))(⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ∨ ¬ cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα0) ∨ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊦

Rule argument

Additional information

Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ (⌜a '⌝ + σ).drop(1) = σ; (s) ⊦ (⌜x⌝ + σ).drop(m + # x) = σ.drop(m); (s) ⊦ n + 0 = n; (s) ⊦ n ≠ 0 → (⌜a '⌝ + σ).drop((* n) + m) = σ.drop((n - 1) + m); (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∞ + n∞1 < n∞1; (s) ⊦ n∞ + ⌜0⌝ = n∞; (s) ⊦ m ≤ n → (⌜(* m)⌝ + n∞2 < ⌜(* n)⌝ + n∞1 ↔ n∞2 < ⌜n - m⌝ + n∞1); (s) ⊦ ⌜m + n⌝ = ⌜m⌝ + ⌜n⌝ ; (s) ⊦ # a ' = 0 +1; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s)

Proof step 123 from proof repls-mon (previous step) (back to tree)

aext !(aal) = [], aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), frag(IOAut(astart, astep, aext))(aσ.drop(# aal), aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), aσ.drop(# aal), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), aσ.drop(# aal), aα0), ¬ frag(IOAut(astart, astep, aext))(⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ∨ ¬ cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα0) ∨ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Proof step 124:
⊦ ⌜n⌝ < # σ → σ.drop(n) = σ[n] + σ.drop(n + 1)
Proof step 125:
aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, aext !(aal) = [], (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(aσ.drop(# aal), aα0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ ⌜# aal⌝ < # aσ, ¬ repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), aσ.drop(# aal), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), aσ.drop(# aal), aα0), ¬ frag(IOAut(astart, astep, aext))(⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ∨ ¬ cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα0) ∨ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊦
Proof step 129:
aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, aext !(aal) = [], (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, ⌜# aal⌝ < # aσ, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(aσ[# aal] + aσ.drop(# aal + 1), aα0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), aσ[# aal] + aσ.drop(# aal + 1), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), aσ[# aal] + aσ.drop(# aal + 1), aα0), ¬ frag(IOAut(astart, astep, aext))(⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ∨ ¬ cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα0) ∨ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊦

Rule argument

spec: stream, name: from-succ, seq: ⊦ ⌜n⌝ < # σ → σ.drop(n) = σ[n] + σ.drop(n + 1), subst:[σ, n] → [aσ, # aal]; ['a] → ['as], <all paths>

Additional information

Used terms: aσ, # aal

Proof step 124 from proof repls-mon (previous step) (back to tree)

⊦ ⌜n⌝ < # σ → σ.drop(n) = σ[n] + σ.drop(n + 1)

A spec-lemma

Proof step 125 from proof repls-mon (previous step) (back to tree)

aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, aext !(aal) = [], (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(aσ.drop(# aal), aα0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ ⌜# aal⌝ < # aσ, ¬ repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), aσ.drop(# aal), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), aσ.drop(# aal), aα0), ¬ frag(IOAut(astart, astep, aext))(⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ∨ ¬ cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα0) ∨ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Proof step 126:
⊦ frag(IOAut(start, step, ext))(σ, α) ↔ # σ = # α + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # α → step(σ[n], α[n], σ[n +1]))
Proof step 127:
aext !(aal) = [], aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, #(⌜as '⌝ + aσ) = #(⌜aal⌝ + ⌜aa '⌝ + aα0) + ⌜1⌝ , (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(aσ.drop(# aal), aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ ⌜# aal⌝ < # aσ, ¬ repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), aσ.drop(# aal), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), aσ.drop(# aal), aα0), ∀ n. ⌜n⌝ < #(⌜aal⌝ + ⌜aa '⌝ + aα0) → astep((⌜as '⌝ + aσ)[n], (⌜aal⌝ + ⌜aa '⌝ + aα0)[n], (⌜as '⌝ + aσ)[n +1]), ¬ frag(IOAut(astart, astep, aext))(⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ∨ ¬ cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα0) ∨ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊦

Rule argument

spec: IOtrace, name: frag, seq:⊦ frag(IOAut(start, step, ext))(σ, α) ↔ # σ = # α + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # α → step(σ[n], α[n], σ[n +1])), subst:[σ, step, α, start, ext] → [⌜as '⌝ + aσ, astep, ⌜aal⌝ + ⌜aa '⌝ + aα0, astart, aext]; ['s, 'a, 'e] → ['as, 'aa, 'e], <all paths>

Additional information

Used terms: aext, ⌜aal⌝ + ⌜aa '⌝ + aα0, astart, ⌜as '⌝ + aσ, astep

Proof step 126 from proof repls-mon (previous step) (back to tree)

⊦ frag(IOAut(start, step, ext))(σ, α) ↔ # σ = # α + ⌜1⌝ ∧ (∀ n. ⌜n⌝ < # α → step(σ[n], α[n], σ[n +1]))

A spec-lemma

Proof step 127 from proof repls-mon (previous step) (back to tree)

aext !(aal) = [], aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, #(⌜as '⌝ + aσ) = #(⌜aal⌝ + ⌜aa '⌝ + aα0) + ⌜1⌝ , (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(aσ.drop(# aal), aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ ⌜# aal⌝ < # aσ, ¬ repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), aσ.drop(# aal), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), aσ.drop(# aal), aα0), ∀ n. ⌜n⌝ < #(⌜aal⌝ + ⌜aa '⌝ + aα0) → astep((⌜as '⌝ + aσ)[n], (⌜aal⌝ + ⌜aa '⌝ + aα0)[n], (⌜as '⌝ + aσ)[n +1]), ¬ frag(IOAut(astart, astep, aext))(⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ∨ ¬ cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα0) ∨ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 128:
aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, aext !(aal) = [], # aσ = ⌜1⌝ + ⌜# aal⌝ + # aα0, (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(aσ.drop(# aal), aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ ⌜# aal⌝ < # aσ, ¬ repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), aσ.drop(# aal), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), aσ.drop(# aal), aα0), ∀ n. ¬ ⌜# aal⌝ + # aα0 < ⌜n⌝ → astep((⌜as '⌝ + aσ)[n], (⌜aal⌝ + ⌜aa '⌝ + aα0)[n], aσ[n]), ¬ frag(IOAut(astart, astep, aext))(⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ∨ ¬ cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα0) ∨ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊦

Rule argument

Additional information

Used simplifier rules: append-assoc: ⊦ (σ + σ1) + σ2 = σ + σ1 + σ2; from specification stream c: ⊦ m + n = n + m; from specification nat-basic a: ⊦ (m + n0) + n1 = m + n0 + n1; from specification nat-basic ⊦ (⌜a '⌝ + σ)[n + 1] = σ[n]; (s) ⊦ m +1 = m + 1; (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⌝ < ⌜1⌝ + n∞ ↔ ¬ n∞ < ⌜n⌝ ; (s) ⊦ # a ' = 0 +1; (s) ⊦ # ⌜x⌝ = ⌜# x⌝ ; (s) ⊦ #(σ + σ1) = # σ + # σ1; (s) ⊦ n < m → (⌜(* n)⌝ + n∞1 = ⌜(* m)⌝ + n∞2 ↔ n∞1 = ⌜m - n⌝ + n∞2); (s) ⊦ ⌜(* n)⌝ + ⌜(* m)⌝ = ⌜n + m⌝ ; (s)

Proof step 128 from proof repls-mon (previous step) (back to tree)

aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, aext !(aal) = [], # aσ = ⌜1⌝ + ⌜# aal⌝ + # aα0, (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(aσ.drop(# aal), aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ ⌜# aal⌝ < # aσ, ¬ repls(step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), aσ.drop(# aal), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), aσ.drop(# aal), aα0), ∀ n. ¬ ⌜# aal⌝ + # aα0 < ⌜n⌝ → astep((⌜as '⌝ + aσ)[n], (⌜aal⌝ + ⌜aa '⌝ + aα0)[n], aσ[n]), ¬ frag(IOAut(astart, astep, aext))(⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ∨ ¬ cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα0) ∨ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊦

User applied rule subst equation

And closed the goal!

Rule argument

pos: left 3, flags: discard

Additional information

Used simplifier rules: ⊦ ⌜n⌝ < ⌜1⌝ + n∞ ↔ ¬ n∞ < ⌜n⌝ ; (s) ⊦ ¬ n∞ + n∞1 < n∞1; (s) add-assoc: ⊦ (n∞ + n∞1) + n∞2 = n∞ + n∞1 + n∞2; from specification nat-inf add-comm: ⊦ n∞1 + n∞2 = n∞2 + n∞1; from specification nat-inf

Proof step 129 from proof repls-mon (previous step) (back to tree)

aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, aext !(aal) = [], (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, ⌜# aal⌝ < # aσ, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(aσ[# aal] + aσ.drop(# aal + 1), aα0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), aσ[# aal] + aσ.drop(# aal + 1), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), aσ[# aal] + aσ.drop(# aal + 1), aα0), ¬ frag(IOAut(astart, astep, aext))(⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ∨ ¬ cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα0) ∨ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 130:
aext !(aal) = [], aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, ⌜# aal⌝ < # aσ, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), frag(IOAut(astart, astep, aext))(⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0), ¬ cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα0) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ a + σ = ⌜a '⌝ + σ; (s)

Proof step 130 from proof repls-mon (previous step) (back to tree)

aext !(aal) = [], aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, ⌜# aal⌝ < # aσ, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), frag(IOAut(astart, astep, aext))(⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0), ¬ cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα0) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Proof step 131:
⊦ σ ⊑ σ0 ↔ (∃ σ1. σ + σ1 = σ0)
Proof step 132:
aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, aext !(aal) = [], (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, ⌜# aal⌝ < # aσ, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0), ∀ σ1. cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + σ1 ≠ aext !(aα0) ⊦

Rule argument

spec: stream, name: prefix-def, seq: ⊦ σ ⊑ σ0 ↔ (∃ σ1. σ + σ1 = σ0), subst:[σ, σ0] → [cext ! (πra (step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )), aext !(aα0)]; ['a] → ['e], <all paths>

Additional information

Used terms: cext ! (πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )), aext !(aα0)

Proof step 131 from proof repls-mon (previous step) (back to tree)

⊦ σ ⊑ σ0 ↔ (∃ σ1. σ + σ1 = σ0)

A spec-lemma

Proof step 132 from proof repls-mon (previous step) (back to tree)

aext !(aα0) = cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + β, aext !(aal) = [], (s0, cs0) = pcsf(0), aext(aa) = Some(e), cext(ca0) = Some(e), paf(0) = cren(ca0), pcsf = (s0, cs0) ' + (λ n. pcsf(n + 1)), ren(a0) = cren(ca0), ext(a0) ≠ None, ⌜# aal⌝ < # aσ, cstep(cs, ca0, cs0), frag(IOAut(astart, astep, aext))(⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, ⌜aal⌝ + ⌜aa '⌝ + aα0), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), step(s, a0, s0), Πok(ext, cext, ren, cren), ¬ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), (λ n. paf(n + 1)).take(n0), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0) ⊑ repls (step, cstep, cren, ren, aren, cext, aext, (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), (λ n. paf(n + 1)).take(n0 + 1), ⌜aσ[# aal] '⌝ + aσ.drop(# aal + 1), aα0), ∀ σ1. cext !(πra(step, cstep, ren, cren, ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜λ n. paf(n + 1)⌝ )) + σ1 ≠ aext !(aα0) ⊦

Heuristic quantifier closing applied rule all left

And closed the goal!

Rule argument

pos: left 19 terms: β

Additional information

Used terms: β

Proof step 133 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), pcsf ≠ (s0, cs0) ' + (λ n. pcsf(n + 1)), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜paf(0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ , cs = cs0 ∧ step(s, a, s0) ∧ paf(0) = ren(a) ∧ ¬ cod(cren)(paf(0)) ∨ s = s0 ∧ cstep(cs, ca, cs0) ∧ paf(0) = cren(ca) ∧ ¬ cod(ren)(paf(0)) ∨ step(s, a0, s0) ∧ ext(a0) ≠ None ∧ paf(0) = ren(a0) ∧ cstep(cs, ca0, cs0) ∧ cext(ca0) ≠ None ∧ paf(0) = cren(ca0) ⊦

User applied rule apply rewrite lemma

And obtained the following new goals

Proof step 134:
⊦ x + nf = (λ n. (n < # x ⊃ x[n];nf(n - # x)))
Proof step 135:
(s0, cs0) = pcsf(0), pcsf ≠ (λ n. (n < # (s0, cs0) ' ⊃ (s0, cs0) '[n];pcsf((n - # (s0, cs0) ') + 1))), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜paf(0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ , cs = cs0 ∧ step(s, a, s0) ∧ paf(0) = ren(a) ∧ ¬ cod(cren)(paf(0)) ∨ s = s0 ∧ cstep(cs, ca, cs0) ∧ paf(0) = cren(ca) ∧ ¬ cod(ren)(paf(0)) ∨ step(s, a0, s0) ∧ ext(a0) ≠ None ∧ paf(0) = ren(a0) ∧ cstep(cs, ca0, cs0) ∧ cext(ca0) ≠ None ∧ paf(0) = cren(ca0) ⊦

Rule argument

spec: stream, name:add-list-fun-def, seq: ⊦ x + nf = (λ n. (n < # x ⊃ x[n];nf(n - # x))), subst:[x, nf] → [(s0, cs0) ', λ n. pcsf(n + 1)]; ['a] → [('s, 'cs)], <all paths>

Additional information

Used terms: (s0, cs0) ', λ n. pcsf(n + 1)

Proof step 134 from proof repls-mon (previous step) (back to tree)

⊦ x + nf = (λ n. (n < # x ⊃ x[n];nf(n - # x)))

A spec-lemma

Proof step 135 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), pcsf ≠ (λ n. (n < # (s0, cs0) ' ⊃ (s0, cs0) '[n];pcsf((n - # (s0, cs0) ') + 1))), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜paf(0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ , cs = cs0 ∧ step(s, a, s0) ∧ paf(0) = ren(a) ∧ ¬ cod(cren)(paf(0)) ∨ s = s0 ∧ cstep(cs, ca, cs0) ∧ paf(0) = cren(ca) ∧ ¬ cod(ren)(paf(0)) ∨ step(s, a0, s0) ∧ ext(a0) ≠ None ∧ paf(0) = ren(a0) ∧ cstep(cs, ca0, cs0) ∧ cext(ca0) ≠ None ∧ paf(0) = cren(ca0) ⊦

Heuristic simplifier applied rule simplifier

And obtained the following new goals

Proof step 136:
(s0, cs0) = pcsf(0), pcsf(n) ≠ (n = 0 ⊃ (s0, cs0);pcsf((n - 1) + 1)), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜paf(0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ , cs = cs0 ∧ step(s, a, s0) ∧ paf(0) = ren(a) ∧ ¬ cod(cren)(paf(0)) ∨ s = s0 ∧ cstep(cs, ca, cs0) ∧ paf(0) = cren(ca) ∧ ¬ cod(ren)(paf(0)) ∨ step(s, a0, s0) ∧ ext(a0) ≠ None ∧ paf(0) = ren(a0) ∧ cstep(cs, ca0, cs0) ∧ cext(ca0) ≠ None ∧ paf(0) = cren(ca0) ⊦

Rule argument

Additional information

Used simplifier rules: ⊦ # a ' = 0 +1; (s) ⊦ a '[0] = a; (s) ⊦ m < 1 ↔ m = 0; (s)

Proof step 136 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), pcsf(n) ≠ (n = 0 ⊃ (s0, cs0);pcsf((n - 1) + 1)), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜paf(0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ , cs = cs0 ∧ step(s, a, s0) ∧ paf(0) = ren(a) ∧ ¬ cod(cren)(paf(0)) ∨ s = s0 ∧ cstep(cs, ca, cs0) ∧ paf(0) = cren(ca) ∧ ¬ cod(ren)(paf(0)) ∨ step(s, a0, s0) ∧ ext(a0) ≠ None ∧ paf(0) = ren(a0) ∧ cstep(cs, ca0, cs0) ∧ cext(ca0) ≠ None ∧ paf(0) = cren(ca0) ⊦

User applied rule case distinction

And obtained the following new goals

Proof step 137:
(s0, cs0) = pcsf(0), n ≠ 0, pcsf(n) ≠ pcsf((n - 1) + 1), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜paf(0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ , cs = cs0 ∧ step(s, a, s0) ∧ paf(0) = ren(a) ∧ ¬ cod(cren)(paf(0)) ∨ s = s0 ∧ cstep(cs, ca, cs0) ∧ paf(0) = cren(ca) ∧ ¬ cod(ren)(paf(0)) ∨ step(s, a0, s0) ∧ ext(a0) ≠ None ∧ paf(0) = ren(a0) ∧ cstep(cs, ca0, cs0) ∧ cext(ca0) ≠ None ∧ paf(0) = cren(ca0) ⊦

Rule argument

pos: left 2

Additional information

Proof step 137 from proof repls-mon (previous step) (back to tree)

(s0, cs0) = pcsf(0), n ≠ 0, pcsf(n) ≠ pcsf((n - 1) + 1), frag(IOAut(astart, astep, aext))(⌜as '⌝ + aσ, aα), fragω(IOAut(Π(start, cstart), Π(step, cstep, ren, cren, ext, cext), Π(ext, cext, ren, cren)))(pcsf, λ n. paf(n + 1)), nounsharedextR(cren, cext, ren), Πok(ext, cext, ren, cren), cext !(πra(step, cstep, ren, cren, ⌜(s, cs) '⌝ + ⌜(s0, cs0) '⌝ + ⌜λ n. pcsf(n + 1)⌝ , ⌜paf(0) '⌝ + ⌜λ n. paf(n + 1)⌝ )) ⊑ aext !(aα), ¬ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0), paf(0) ' + (λ n. paf(n + 1)).take(n0), ⌜as '⌝ + aσ, aα) ⌝ ⊑ ⌜repls (step, cstep, cren, ren, aren, cext, aext, (s, cs) ' + (s0, cs0) ' + (λ n. pcsf(n + 1)).take(n0 + 1), paf(0) ' + (λ n. paf(n + 1)).take(n0 + 1), ⌜as '⌝ + aσ, aα) ⌝ , ∀ astart0, astep0, aext0, as0, aσ0, aα0, start0, cstart0, step0, cstep0, ren0, cren0, ext0, cext0, s0, cs0, pcsf0, paf0, aren0. ¬ frag(IOAut(astart0, astep0, aext0))(⌜as0 '⌝ + aσ0, aα0) ∨ ¬ fragω(IOAut(Π(start0, cstart0), Π(step0, cstep0, ren0, cren0, ext0, cext0), Π(ext0, cext0, ren0, cren0)))((s0, cs0) ' + pcsf0, paf0) ∨ ¬ nounsharedextR(cren0, cext0, ren0) ∨ ¬ Πok(ext0, cext0, ren0, cren0) ∨ ¬ cext0 !(πra(step0, cstep0, ren0, cren0, ⌜(s0, cs0) '⌝ + ⌜pcsf0⌝ , ⌜paf0⌝ )) ⊑ aext0 !(aα0) ∨ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0), paf0.take(n0), ⌜as0 '⌝ + aσ0, aα0)⌝ ⊑ ⌜repls(step0, cstep0, cren0, ren0, aren0, cext0, aext0, (s0, cs0) ' + pcsf0.take(n0 + 1), paf0.take(n0 + 1), ⌜as0 '⌝ + aσ0, aα0)⌝ , cs = cs0 ∧ step(s, a, s0) ∧ paf(0) = ren(a) ∧ ¬ cod(cren)(paf(0)) ∨ s = s0 ∧ cstep(cs, ca, cs0) ∧ paf(0) = cren(ca) ∧ ¬ cod(ren)(paf(0)) ∨ step(s, a0, s0) ∧ ext(a0) ≠ None ∧ paf(0) = ren(a0) ∧ cstep(cs, ca0, cs0) ∧ cext(ca0) ≠ None ∧ paf(0) = cren(ca0) ⊦

Heuristic elimination applied rule apply elim lemma

And closed the goal!

Rule argument

spec: nat, name:elim-pred-c, seq:n ≠ 0 ⊦ m = n - 1 ↔ n = m + 1, subst:[n, m] → [n, n1]

Additional information

Used simplifier rules: n ≠ 0 ⊦ m = n - 1 ↔ n = m + 1; (elim) Used terms: n, n1