/export/starexec/sandbox2/solver/bin/starexec_run_default /export/starexec/sandbox2/benchmark/theBenchmark.xml /export/starexec/sandbox2/output/output_files


--------------------------------------------------------------------------------


YES

Problem 1: 

(VAR v w ws x' xs xs' y y' ys ys' z zs)
(RULES
get(cons(x',xs')) -> tp2(y,cons(x',zs)) | get(xs') -> tp2(y,zs)
get(cons(y,ys)) -> tp2(y,ys)
ssp'(cons(x',xs'),v) -> cons(y',ys') | get(xs') -> tp2(y',zs), sub(v,y') -> w, ssp'(cons(x',zs),w) -> ys'
ssp'(cons(y',ws),v) -> cons(y',ys') | sub(v,y') -> w, ssp'(ws,w) -> ys'
ssp'(xs,0) -> nil
sub(s(v),s(w)) -> z | sub(v,w) -> z
sub(z,0) -> z
)

Problem 1: 
Valid CTRS Processor:
-> Rules:
 get(cons(x',xs')) -> tp2(y,cons(x',zs)) | get(xs') -> tp2(y,zs)
 get(cons(y,ys)) -> tp2(y,ys)
 ssp'(cons(x',xs'),v) -> cons(y',ys') | get(xs') -> tp2(y',zs), sub(v,y') -> w, ssp'(cons(x',zs),w) -> ys'
 ssp'(cons(y',ws),v) -> cons(y',ys') | sub(v,y') -> w, ssp'(ws,w) -> ys'
 ssp'(xs,0) -> nil
 sub(s(v),s(w)) -> z | sub(v,w) -> z
 sub(z,0) -> z
-> The system is a deterministic 3-CTRS.

Problem 1: 

Dependency Pairs Processor:

Conditional Termination Problem 1:
-> Pairs:
 Empty
-> QPairs:
 Empty
-> Rules:
 get(cons(x',xs')) -> tp2(y,cons(x',zs)) | get(xs') -> tp2(y,zs)
 get(cons(y,ys)) -> tp2(y,ys)
 ssp'(cons(x',xs'),v) -> cons(y',ys') | get(xs') -> tp2(y',zs), sub(v,y') -> w, ssp'(cons(x',zs),w) -> ys'
 ssp'(cons(y',ws),v) -> cons(y',ys') | sub(v,y') -> w, ssp'(ws,w) -> ys'
 ssp'(xs,0) -> nil
 sub(s(v),s(w)) -> z | sub(v,w) -> z
 sub(z,0) -> z

Conditional Termination Problem 2:
-> Pairs:
 GET(cons(x',xs')) -> GET(xs')
 SSP'(cons(x',xs'),v) -> GET(xs')
 SSP'(cons(x',xs'),v) -> SSP'(cons(x',zs),w) | get(xs') -> tp2(y',zs), sub(v,y') -> w
 SSP'(cons(x',xs'),v) -> SUB(v,y') | get(xs') -> tp2(y',zs)
 SSP'(cons(y',ws),v) -> SSP'(ws,w) | sub(v,y') -> w
 SSP'(cons(y',ws),v) -> SUB(v,y')
 SUB(s(v),s(w)) -> SUB(v,w)
-> QPairs:
 Empty
-> Rules:
 get(cons(x',xs')) -> tp2(y,cons(x',zs)) | get(xs') -> tp2(y,zs)
 get(cons(y,ys)) -> tp2(y,ys)
 ssp'(cons(x',xs'),v) -> cons(y',ys') | get(xs') -> tp2(y',zs), sub(v,y') -> w, ssp'(cons(x',zs),w) -> ys'
 ssp'(cons(y',ws),v) -> cons(y',ys') | sub(v,y') -> w, ssp'(ws,w) -> ys'
 ssp'(xs,0) -> nil
 sub(s(v),s(w)) -> z | sub(v,w) -> z
 sub(z,0) -> z


The problem is decomposed in 2 subproblems.

Problem 1.1: 

SCC Processor:
-> Pairs:
 Empty
-> QPairs:
 Empty
-> Rules:
 get(cons(x',xs')) -> tp2(y,cons(x',zs)) | get(xs') -> tp2(y,zs)
 get(cons(y,ys)) -> tp2(y,ys)
 ssp'(cons(x',xs'),v) -> cons(y',ys') | get(xs') -> tp2(y',zs), sub(v,y') -> w, ssp'(cons(x',zs),w) -> ys'
 ssp'(cons(y',ws),v) -> cons(y',ys') | sub(v,y') -> w, ssp'(ws,w) -> ys'
 ssp'(xs,0) -> nil
 sub(s(v),s(w)) -> z | sub(v,w) -> z
 sub(z,0) -> z
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.

Problem 1.2: 

SCC Processor:
-> Pairs:
 GET(cons(x',xs')) -> GET(xs')
 SSP'(cons(x',xs'),v) -> GET(xs')
 SSP'(cons(x',xs'),v) -> SSP'(cons(x',zs),w) | get(xs') -> tp2(y',zs), sub(v,y') -> w
 SSP'(cons(x',xs'),v) -> SUB(v,y') | get(xs') -> tp2(y',zs)
 SSP'(cons(y',ws),v) -> SSP'(ws,w) | sub(v,y') -> w
 SSP'(cons(y',ws),v) -> SUB(v,y')
 SUB(s(v),s(w)) -> SUB(v,w)
-> QPairs:
 Empty
-> Rules:
 get(cons(x',xs')) -> tp2(y,cons(x',zs)) | get(xs') -> tp2(y,zs)
 get(cons(y,ys)) -> tp2(y,ys)
 ssp'(cons(x',xs'),v) -> cons(y',ys') | get(xs') -> tp2(y',zs), sub(v,y') -> w, ssp'(cons(x',zs),w) -> ys'
 ssp'(cons(y',ws),v) -> cons(y',ys') | sub(v,y') -> w, ssp'(ws,w) -> ys'
 ssp'(xs,0) -> nil
 sub(s(v),s(w)) -> z | sub(v,w) -> z
 sub(z,0) -> z
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 SUB(s(v),s(w)) -> SUB(v,w)
->->-> Rules:
 get(cons(x',xs')) -> tp2(y,cons(x',zs)) | get(xs') -> tp2(y,zs)
 get(cons(y,ys)) -> tp2(y,ys)
 ssp'(cons(x',xs'),v) -> cons(y',ys') | get(xs') -> tp2(y',zs), sub(v,y') -> w, ssp'(cons(x',zs),w) -> ys'
 ssp'(cons(y',ws),v) -> cons(y',ys') | sub(v,y') -> w, ssp'(ws,w) -> ys'
 ssp'(xs,0) -> nil
 sub(s(v),s(w)) -> z | sub(v,w) -> z
 sub(z,0) -> z
->->Cycle:
->->-> Pairs:
 GET(cons(x',xs')) -> GET(xs')
->->-> Rules:
 get(cons(x',xs')) -> tp2(y,cons(x',zs)) | get(xs') -> tp2(y,zs)
 get(cons(y,ys)) -> tp2(y,ys)
 ssp'(cons(x',xs'),v) -> cons(y',ys') | get(xs') -> tp2(y',zs), sub(v,y') -> w, ssp'(cons(x',zs),w) -> ys'
 ssp'(cons(y',ws),v) -> cons(y',ys') | sub(v,y') -> w, ssp'(ws,w) -> ys'
 ssp'(xs,0) -> nil
 sub(s(v),s(w)) -> z | sub(v,w) -> z
 sub(z,0) -> z
->->Cycle:
->->-> Pairs:
 SSP'(cons(x',xs'),v) -> SSP'(cons(x',zs),w) | get(xs') -> tp2(y',zs), sub(v,y') -> w
 SSP'(cons(y',ws),v) -> SSP'(ws,w) | sub(v,y') -> w
->->-> Rules:
 get(cons(x',xs')) -> tp2(y,cons(x',zs)) | get(xs') -> tp2(y,zs)
 get(cons(y,ys)) -> tp2(y,ys)
 ssp'(cons(x',xs'),v) -> cons(y',ys') | get(xs') -> tp2(y',zs), sub(v,y') -> w, ssp'(cons(x',zs),w) -> ys'
 ssp'(cons(y',ws),v) -> cons(y',ys') | sub(v,y') -> w, ssp'(ws,w) -> ys'
 ssp'(xs,0) -> nil
 sub(s(v),s(w)) -> z | sub(v,w) -> z
 sub(z,0) -> z


The problem is decomposed in 3 subproblems.

Problem 1.2.1: 

Conditional Subterm Processor:
-> Pairs:
 SUB(s(v),s(w)) -> SUB(v,w)
-> QPairs:
 Empty
-> Rules:
 get(cons(x',xs')) -> tp2(y,cons(x',zs)) | get(xs') -> tp2(y,zs)
 get(cons(y,ys)) -> tp2(y,ys)
 ssp'(cons(x',xs'),v) -> cons(y',ys') | get(xs') -> tp2(y',zs), sub(v,y') -> w, ssp'(cons(x',zs),w) -> ys'
 ssp'(cons(y',ws),v) -> cons(y',ys') | sub(v,y') -> w, ssp'(ws,w) -> ys'
 ssp'(xs,0) -> nil
 sub(s(v),s(w)) -> z | sub(v,w) -> z
 sub(z,0) -> z
->Projection:
 pi(SUB) = 1

Problem 1.2.1: 

SCC Processor:
-> Pairs:
 Empty
-> QPairs:
 Empty
-> Rules:
 get(cons(x',xs')) -> tp2(y,cons(x',zs)) | get(xs') -> tp2(y,zs)
 get(cons(y,ys)) -> tp2(y,ys)
 ssp'(cons(x',xs'),v) -> cons(y',ys') | get(xs') -> tp2(y',zs), sub(v,y') -> w, ssp'(cons(x',zs),w) -> ys'
 ssp'(cons(y',ws),v) -> cons(y',ys') | sub(v,y') -> w, ssp'(ws,w) -> ys'
 ssp'(xs,0) -> nil
 sub(s(v),s(w)) -> z | sub(v,w) -> z
 sub(z,0) -> z
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.

Problem 1.2.2: 

Conditional Subterm Processor:
-> Pairs:
 GET(cons(x',xs')) -> GET(xs')
-> QPairs:
 Empty
-> Rules:
 get(cons(x',xs')) -> tp2(y,cons(x',zs)) | get(xs') -> tp2(y,zs)
 get(cons(y,ys)) -> tp2(y,ys)
 ssp'(cons(x',xs'),v) -> cons(y',ys') | get(xs') -> tp2(y',zs), sub(v,y') -> w, ssp'(cons(x',zs),w) -> ys'
 ssp'(cons(y',ws),v) -> cons(y',ys') | sub(v,y') -> w, ssp'(ws,w) -> ys'
 ssp'(xs,0) -> nil
 sub(s(v),s(w)) -> z | sub(v,w) -> z
 sub(z,0) -> z
->Projection:
 pi(GET) = 1

Problem 1.2.2: 

SCC Processor:
-> Pairs:
 Empty
-> QPairs:
 Empty
-> Rules:
 get(cons(x',xs')) -> tp2(y,cons(x',zs)) | get(xs') -> tp2(y,zs)
 get(cons(y,ys)) -> tp2(y,ys)
 ssp'(cons(x',xs'),v) -> cons(y',ys') | get(xs') -> tp2(y',zs), sub(v,y') -> w, ssp'(cons(x',zs),w) -> ys'
 ssp'(cons(y',ws),v) -> cons(y',ys') | sub(v,y') -> w, ssp'(ws,w) -> ys'
 ssp'(xs,0) -> nil
 sub(s(v),s(w)) -> z | sub(v,w) -> z
 sub(z,0) -> z
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.

Problem 1.2.3: 

Reduction Triple Processor:
-> Pairs:
 SSP'(cons(x',xs'),v) -> SSP'(cons(x',zs),w) | get(xs') -> tp2(y',zs), sub(v,y') -> w
 SSP'(cons(y',ws),v) -> SSP'(ws,w) | sub(v,y') -> w
-> QPairs:
 Empty
-> Rules:
 get(cons(x',xs')) -> tp2(y,cons(x',zs)) | get(xs') -> tp2(y,zs)
 get(cons(y,ys)) -> tp2(y,ys)
 ssp'(cons(x',xs'),v) -> cons(y',ys') | get(xs') -> tp2(y',zs), sub(v,y') -> w, ssp'(cons(x',zs),w) -> ys'
 ssp'(cons(y',ws),v) -> cons(y',ys') | sub(v,y') -> w, ssp'(ws,w) -> ys'
 ssp'(xs,0) -> nil
 sub(s(v),s(w)) -> z | sub(v,w) -> z
 sub(z,0) -> z
-> Usable rules:
 get(cons(x',xs')) -> tp2(y,cons(x',zs)) | get(xs') -> tp2(y,zs)
 get(cons(y,ys)) -> tp2(y,ys)
 sub(s(v),s(w)) -> z | sub(v,w) -> z
 sub(z,0) -> z
->Interpretation type:
 Linear
->Coefficients:
 Integer Numbers
->Dimension:
 1
->Convex Domain:
 D[(x_1)] = ((0 >= 0) /\ (-1+x_1 >= 0))
->Interpretation:
 
[delta] = 1
[get](x_1) = x_1
[sub](x_1,x_2) = -1+x_1+x_2
[0] = 1
[cons](x_1,x_2) = x_1+x_2
[s](x_1) = 2.x_1
[tp2](x_1,x_2) = x_1+x_2
[SSP'](x_1,x_2) = 1+x_1

Problem 1.2.3: 

SCC Processor:
-> Pairs:
 SSP'(cons(y',ws),v) -> SSP'(ws,w) | sub(v,y') -> w
-> QPairs:
 Empty
-> Rules:
 get(cons(x',xs')) -> tp2(y,cons(x',zs)) | get(xs') -> tp2(y,zs)
 get(cons(y,ys)) -> tp2(y,ys)
 ssp'(cons(x',xs'),v) -> cons(y',ys') | get(xs') -> tp2(y',zs), sub(v,y') -> w, ssp'(cons(x',zs),w) -> ys'
 ssp'(cons(y',ws),v) -> cons(y',ys') | sub(v,y') -> w, ssp'(ws,w) -> ys'
 ssp'(xs,0) -> nil
 sub(s(v),s(w)) -> z | sub(v,w) -> z
 sub(z,0) -> z
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 SSP'(cons(y',ws),v) -> SSP'(ws,w) | sub(v,y') -> w
->->-> Rules:
 get(cons(x',xs')) -> tp2(y,cons(x',zs)) | get(xs') -> tp2(y,zs)
 get(cons(y,ys)) -> tp2(y,ys)
 ssp'(cons(x',xs'),v) -> cons(y',ys') | get(xs') -> tp2(y',zs), sub(v,y') -> w, ssp'(cons(x',zs),w) -> ys'
 ssp'(cons(y',ws),v) -> cons(y',ys') | sub(v,y') -> w, ssp'(ws,w) -> ys'
 ssp'(xs,0) -> nil
 sub(s(v),s(w)) -> z | sub(v,w) -> z
 sub(z,0) -> z

Problem 1.2.3: 

Conditional Subterm Processor:
-> Pairs:
 SSP'(cons(y',ws),v) -> SSP'(ws,w) | sub(v,y') -> w
-> QPairs:
 Empty
-> Rules:
 get(cons(x',xs')) -> tp2(y,cons(x',zs)) | get(xs') -> tp2(y,zs)
 get(cons(y,ys)) -> tp2(y,ys)
 ssp'(cons(x',xs'),v) -> cons(y',ys') | get(xs') -> tp2(y',zs), sub(v,y') -> w, ssp'(cons(x',zs),w) -> ys'
 ssp'(cons(y',ws),v) -> cons(y',ys') | sub(v,y') -> w, ssp'(ws,w) -> ys'
 ssp'(xs,0) -> nil
 sub(s(v),s(w)) -> z | sub(v,w) -> z
 sub(z,0) -> z
->Projection:
 pi(SSP') = 1

Problem 1.2.3: 

SCC Processor:
-> Pairs:
 Empty
-> QPairs:
 Empty
-> Rules:
 get(cons(x',xs')) -> tp2(y,cons(x',zs)) | get(xs') -> tp2(y,zs)
 get(cons(y,ys)) -> tp2(y,ys)
 ssp'(cons(x',xs'),v) -> cons(y',ys') | get(xs') -> tp2(y',zs), sub(v,y') -> w, ssp'(cons(x',zs),w) -> ys'
 ssp'(cons(y',ws),v) -> cons(y',ys') | sub(v,y') -> w, ssp'(ws,w) -> ys'
 ssp'(xs,0) -> nil
 sub(s(v),s(w)) -> z | sub(v,w) -> z
 sub(z,0) -> z
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.