details

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

run statistics

property	value
solver	Wanda
configuration	HigherOrder
runtime (wallclock)	0.438517093658 seconds
cpu usage	0.435566831
max memory	2.1241856E7

stage attributes

key	value
output-size	13739
starexec-result	YES

output

/export/starexec/sandbox2/solver/bin/starexec_run_HigherOrder /export/starexec/sandbox2/benchmark/theBenchmark.xml /export/starexec/sandbox2/output/output_files -------------------------------------------------------------------------------- YES We consider the system theBenchmark. Alphabet: 0 : [] --> nat cons : [nat * list] --> list map : [nat -> nat * list] --> list nil : [] --> list op : [nat -> nat * nat -> nat] --> nat -> nat pow : [nat -> nat * nat] --> nat -> nat s : [nat] --> nat Rules: map(f, nil) => nil map(f, cons(x, y)) => cons(f x, map(f, y)) pow(f, 0) => /\x.x pow(f, s(x)) => op(f, pow(f, x)) op(f, g) x => f (g x) /\x.f x => f Using the transformations described in [Kop11], this system can be brought in a form without leading free variables in the left-hand side, and where the left-hand side of a variable is always a functional term or application headed by a functional term. We now transform the resulting AFS into an AFSM by replacing all free variables by meta-variables (with arity 0). This leads to the following AFSM: Alphabet: 0 : [] --> nat cons : [nat * list] --> list map : [nat -> nat * list] --> list nil : [] --> list op : [nat -> nat * nat -> nat] --> nat -> nat pow : [nat -> nat * nat] --> nat -> nat s : [nat] --> nat ~AP1 : [nat -> nat * nat] --> nat ~L1 : [nat -> nat] --> nat -> nat Rules: map(F, nil) => nil map(F, cons(X, Y)) => cons(~AP1(F, X), map(F, Y)) pow(F, 0) => ~L1(/\x.x) pow(F, s(X)) => op(F, pow(F, X)) op(F, G) X => ~AP1(F, ~AP1(G, X)) ~L1(/\x.~AP1(F, x)) => F ~L1(/\x.op(F, G) x) => op(F, G) ~L1(/\x.pow(F, X) x) => pow(F, X) ~AP1(F, X) => F X ~L1(F) => F We use rule removal, following [Kop12, Theorem 2.23]. This gives the following requirements (possibly using Theorems 2.25 and 2.26 in [Kop12]): map(F, nil) >? nil map(F, cons(X, Y)) >? cons(~AP1(F, X), map(F, Y)) pow(F, 0) >? ~L1(/\x.x) pow(F, s(X)) >? op(F, pow(F, X)) op(F, G) X >? ~AP1(F, ~AP1(G, X)) ~L1(/\x.~AP1(F, x)) >? F ~L1(/\x.op(F, G) x) >? op(F, G) ~L1(/\x.pow(F, X) x) >? pow(F, X) ~AP1(F, X) >? F X ~L1(F) >? F about to try horpo We use a recursive path ordering as defined in [Kop12, Chapter 5]. Argument functions: [[nil]] = _|_ We choose Lex = {} and Mul = {0, @_{o -> o}, cons, map, op, pow, s, ~AP1, ~L1}, and the following precedence: 0 > map > cons > pow > s > ~L1 > op > ~AP1 > @_{o -> o} Taking the argument function into account, and fixing the greater / greater equal choices, the constraints can be denoted as follows: map(F, _|_) >= _|_ map(F, cons(X, Y)) >= cons(~AP1(F, X), map(F, Y)) pow(F, 0) >= ~L1(/\x.x) pow(F, s(X)) >= op(F, pow(F, X)) @_{o -> o}(op(F, G), X) >= ~AP1(F, ~AP1(G, X)) ~L1(/\x.~AP1(F, x)) >= F ~L1(/\x.@_{o -> o}(op(F, G), x)) > op(F, G) ~L1(/\x.@_{o -> o}(pow(F, X), x)) >= pow(F, X) ~AP1(F, X) > @_{o -> o}(F, X) ~L1(F) >= F With these choices, we have: 1] map(F, _|_) >= _|_ by (Bot) 2] map(F, cons(X, Y)) >= cons(~AP1(F, X), map(F, Y)) because [3], by (Star) popout

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

job log

popout

actions

all output return to HRS union beta 16688