details

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

run statistics

property	value
solver	Wanda
configuration	HigherOrder
runtime (wallclock)	0.0643520355225 seconds
cpu usage	0.058689856
max memory	3940352.0

stage attributes

key	value
output-size	3371
starexec-result	YES

output

/export/starexec/sandbox/solver/bin/starexec_run_HigherOrder /export/starexec/sandbox/benchmark/theBenchmark.xml /export/starexec/sandbox/output/output_files -------------------------------------------------------------------------------- YES We consider the system theBenchmark. Alphabet: comp : [a -> a * a -> a] --> a -> a twice : [a -> a] --> a -> a Rules: comp(f, g) x => f (g x) twice(f) => comp(f, f) This AFS is converted to an AFSM simply by replacing all free variables by meta-variables (with arity 0). We use rule removal, following [Kop12, Theorem 2.23]. This gives the following requirements (possibly using Theorems 2.25 and 2.26 in [Kop12]): comp(F, G) X >? F (G X) twice(F) >? comp(F, F) about to try horpo We use a recursive path ordering as defined in [Kop12, Chapter 5]. We choose Lex = {} and Mul = {@_{o -> o}, comp, twice}, and the following precedence: twice > comp > @_{o -> o} With these choices, we have: 1] @_{o -> o}(comp(F, G), X) >= @_{o -> o}(F, @_{o -> o}(G, X)) because [2], by (Star) 2] @_{o -> o}*(comp(F, G), X) >= @_{o -> o}(F, @_{o -> o}(G, X)) because [3], by (Select) 3] comp(F, G) @_{o -> o}*(comp(F, G), X) >= @_{o -> o}(F, @_{o -> o}(G, X)) because [4] 4] comp*(F, G, @_{o -> o}*(comp(F, G), X)) >= @_{o -> o}(F, @_{o -> o}(G, X)) because comp > @_{o -> o}, [5] and [7], by (Copy) 5] comp*(F, G, @_{o -> o}*(comp(F, G), X)) >= F because [6], by (Select) 6] F >= F by (Meta) 7] comp*(F, G, @_{o -> o}*(comp(F, G), X)) >= @_{o -> o}(G, X) because comp > @_{o -> o}, [8] and [10], by (Copy) 8] comp*(F, G, @_{o -> o}*(comp(F, G), X)) >= G because [9], by (Select) 9] G >= G by (Meta) 10] comp*(F, G, @_{o -> o}*(comp(F, G), X)) >= X because [11], by (Select) 11] @_{o -> o}*(comp(F, G), X) >= X because [12], by (Select) 12] X >= X by (Meta) 13] twice(F) > comp(F, F) because [14], by definition 14] twice*(F) >= comp(F, F) because twice > comp, [15] and [15], by (Copy) 15] twice*(F) >= F because [16], by (Select) 16] F >= F by (Meta) We can thus remove the following rules: twice(F) => comp(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]): comp(F, G, X) >? F (G X) about to try horpo We use a recursive path ordering as defined in [Kop12, Chapter 5]. We choose Lex = {} and Mul = {@_{o -> o}, comp}, and the following precedence: comp > @_{o -> o} With these choices, we have: 1] comp(F, G, X) > @_{o -> o}(F, @_{o -> o}(G, X)) because [2], by definition 2] comp*(F, G, X) >= @_{o -> o}(F, @_{o -> o}(G, X)) because comp > @_{o -> o}, [3] and [5], by (Copy) 3] comp*(F, G, X) >= F because [4], by (Select) 4] F >= F by (Meta) 5] comp*(F, G, X) >= @_{o -> o}(G, X) because comp > @_{o -> o}, [6] and [8], by (Copy) 6] comp*(F, G, X) >= G because [7], by (Select) 7] G >= G by (Meta) 8] comp*(F, G, X) >= X because [9], by (Select) 9] X >= X by (Meta) We can thus remove the following rules: comp(F, G, X) => F (G X) All rules were succesfully removed. Thus, termination of the original system has been reduced to termination of the beta-rule, which is well-known to hold. +++ Citations +++ [Kop12] C. Kop. Higher Order Termination. PhD Thesis, 2012. popout

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

job log

popout

actions

all output return to HRS union beta 16688