details

property	value
status	complete
benchmark	Ex15_Luc98_iGM.xml
ran by	Akihisa Yamada
cpu timeout	1200 seconds
wallclock timeout	300 seconds
memory limit	137438953472 bytes
execution host	n042.star.cs.uiowa.edu
space	Transformed_CSR_04

run statistics

property	value
solver	Wanda
configuration	FirstOrder
runtime (wallclock)	0.745480060577 seconds
cpu usage	0.719516431
max memory	2.3310336E7

stage attributes

key	value
output-size	32992
starexec-result	YES

output

/export/starexec/sandbox2/solver/bin/starexec_run_FirstOrder /export/starexec/sandbox2/benchmark/theBenchmark.xml /export/starexec/sandbox2/output/output_files -------------------------------------------------------------------------------- YES We consider the system theBenchmark. We are asked to determine termination of the following first-order TRS. 0 : [] --> o active : [o] --> o add : [o * o] --> o and : [o * o] --> o cons : [o * o] --> o false : [] --> o first : [o * o] --> o from : [o] --> o if : [o * o * o] --> o mark : [o] --> o nil : [] --> o s : [o] --> o true : [] --> o active(and(true, X)) => mark(X) active(and(false, X)) => mark(false) active(if(true, X, Y)) => mark(X) active(if(false, X, Y)) => mark(Y) active(add(0, X)) => mark(X) active(add(s(X), Y)) => mark(s(add(X, Y))) active(first(0, X)) => mark(nil) active(first(s(X), cons(Y, Z))) => mark(cons(Y, first(X, Z))) active(from(X)) => mark(cons(X, from(s(X)))) mark(and(X, Y)) => active(and(mark(X), Y)) mark(true) => active(true) mark(false) => active(false) mark(if(X, Y, Z)) => active(if(mark(X), Y, Z)) mark(add(X, Y)) => active(add(mark(X), Y)) mark(0) => active(0) mark(s(X)) => active(s(X)) mark(first(X, Y)) => active(first(mark(X), mark(Y))) mark(nil) => active(nil) mark(cons(X, Y)) => active(cons(X, Y)) mark(from(X)) => active(from(X)) and(mark(X), Y) => and(X, Y) and(X, mark(Y)) => and(X, Y) and(active(X), Y) => and(X, Y) and(X, active(Y)) => and(X, Y) if(mark(X), Y, Z) => if(X, Y, Z) if(X, mark(Y), Z) => if(X, Y, Z) if(X, Y, mark(Z)) => if(X, Y, Z) if(active(X), Y, Z) => if(X, Y, Z) if(X, active(Y), Z) => if(X, Y, Z) if(X, Y, active(Z)) => if(X, Y, Z) add(mark(X), Y) => add(X, Y) add(X, mark(Y)) => add(X, Y) add(active(X), Y) => add(X, Y) add(X, active(Y)) => add(X, Y) s(mark(X)) => s(X) s(active(X)) => s(X) first(mark(X), Y) => first(X, Y) first(X, mark(Y)) => first(X, Y) first(active(X), Y) => first(X, Y) first(X, active(Y)) => first(X, Y) cons(mark(X), Y) => cons(X, Y) cons(X, mark(Y)) => cons(X, Y) cons(active(X), Y) => cons(X, Y) cons(X, active(Y)) => cons(X, Y) from(mark(X)) => from(X) from(active(X)) => from(X) We use the dependency pair framework as described in [Kop12, Ch. 6/7], with static dependency pairs (see [KusIsoSakBla09] and the adaptation for AFSMs in [Kop12, Ch. 7.8]). We thus obtain the following dependency pair problem (P_0, R_0, minimal, formative): Dependency Pairs P_0: 0] active#(and(true, X)) =#> mark#(X) 1] active#(and(false, X)) =#> mark#(false) 2] active#(if(true, X, Y)) =#> mark#(X) 3] active#(if(false, X, Y)) =#> mark#(Y) 4] active#(add(0, X)) =#> mark#(X) 5] active#(add(s(X), Y)) =#> mark#(s(add(X, Y))) 6] active#(add(s(X), Y)) =#> s#(add(X, Y)) 7] active#(add(s(X), Y)) =#> add#(X, Y) 8] active#(first(0, X)) =#> mark#(nil) 9] active#(first(s(X), cons(Y, Z))) =#> mark#(cons(Y, first(X, Z))) 10] active#(first(s(X), cons(Y, Z))) =#> cons#(Y, first(X, Z)) 11] active#(first(s(X), cons(Y, Z))) =#> first#(X, Z) 12] active#(from(X)) =#> mark#(cons(X, from(s(X)))) 13] active#(from(X)) =#> cons#(X, from(s(X))) 14] active#(from(X)) =#> from#(s(X)) 15] active#(from(X)) =#> s#(X) 16] mark#(and(X, Y)) =#> active#(and(mark(X), Y)) 17] mark#(and(X, Y)) =#> and#(mark(X), Y) 18] mark#(and(X, Y)) =#> mark#(X) 19] mark#(true) =#> active#(true) 20] mark#(false) =#> active#(false) 21] mark#(if(X, Y, Z)) =#> active#(if(mark(X), Y, Z)) popout

output may be truncated. 'popout' for the full output.

job log

popout

actions

all output return to TRS Stand 20472