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


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


YES

Problem 1: 

(VAR v_NonEmpty:S l:S m:S n:S)
(RULES
insert(cons(n:S,l:S),m:S) -> cons(m:S,cons(n:S,l:S)) | lte(m:S,n:S) ->* ttrue
insert(cons(n:S,l:S),m:S) -> cons(n:S,insert(l:S,m:S)) | lte(m:S,n:S) ->* ffalse
insert(nil,m:S) -> cons(m:S,nil)
lte(0,n:S) -> ttrue
lte(s(m:S),0) -> ffalse
lte(s(m:S),s(n:S)) -> lte(m:S,n:S)
ordered(cons(m:S,cons(n:S,l:S))) -> ordered(cons(n:S,l:S)) | lte(m:S,n:S) ->* ttrue
ordered(cons(m:S,cons(n:S,l:S))) -> ffalse | lte(m:S,n:S) ->* ffalse
ordered(cons(m:S,nil)) -> ttrue
ordered(nil) -> ttrue
)

Problem 1: 
Valid CTRS Processor:
-> Rules:
 insert(cons(n:S,l:S),m:S) -> cons(m:S,cons(n:S,l:S)) | lte(m:S,n:S) ->* ttrue
 insert(cons(n:S,l:S),m:S) -> cons(n:S,insert(l:S,m:S)) | lte(m:S,n:S) ->* ffalse
 insert(nil,m:S) -> cons(m:S,nil)
 lte(0,n:S) -> ttrue
 lte(s(m:S),0) -> ffalse
 lte(s(m:S),s(n:S)) -> lte(m:S,n:S)
 ordered(cons(m:S,cons(n:S,l:S))) -> ordered(cons(n:S,l:S)) | lte(m:S,n:S) ->* ttrue
 ordered(cons(m:S,cons(n:S,l:S))) -> ffalse | lte(m:S,n:S) ->* ffalse
 ordered(cons(m:S,nil)) -> ttrue
 ordered(nil) -> ttrue
-> The system is a deterministic 3-CTRS.

Problem 1: 

Dependency Pairs Processor:

Conditional Termination Problem 1:
-> Pairs:
 INSERT(cons(n:S,l:S),m:S) -> INSERT(l:S,m:S) | lte(m:S,n:S) ->* ffalse
 LTE(s(m:S),s(n:S)) -> LTE(m:S,n:S)
 ORDERED(cons(m:S,cons(n:S,l:S))) -> ORDERED(cons(n:S,l:S)) | lte(m:S,n:S) ->* ttrue
-> QPairs:
 Empty
-> Rules:
 insert(cons(n:S,l:S),m:S) -> cons(m:S,cons(n:S,l:S)) | lte(m:S,n:S) ->* ttrue
 insert(cons(n:S,l:S),m:S) -> cons(n:S,insert(l:S,m:S)) | lte(m:S,n:S) ->* ffalse
 insert(nil,m:S) -> cons(m:S,nil)
 lte(0,n:S) -> ttrue
 lte(s(m:S),0) -> ffalse
 lte(s(m:S),s(n:S)) -> lte(m:S,n:S)
 ordered(cons(m:S,cons(n:S,l:S))) -> ordered(cons(n:S,l:S)) | lte(m:S,n:S) ->* ttrue
 ordered(cons(m:S,cons(n:S,l:S))) -> ffalse | lte(m:S,n:S) ->* ffalse
 ordered(cons(m:S,nil)) -> ttrue
 ordered(nil) -> ttrue

Conditional Termination Problem 2:
-> Pairs:
 INSERT(cons(n:S,l:S),m:S) -> LTE(m:S,n:S)
 ORDERED(cons(m:S,cons(n:S,l:S))) -> LTE(m:S,n:S)
-> QPairs:
 LTE(s(m:S),s(n:S)) -> LTE(m:S,n:S)
-> Rules:
 insert(cons(n:S,l:S),m:S) -> cons(m:S,cons(n:S,l:S)) | lte(m:S,n:S) ->* ttrue
 insert(cons(n:S,l:S),m:S) -> cons(n:S,insert(l:S,m:S)) | lte(m:S,n:S) ->* ffalse
 insert(nil,m:S) -> cons(m:S,nil)
 lte(0,n:S) -> ttrue
 lte(s(m:S),0) -> ffalse
 lte(s(m:S),s(n:S)) -> lte(m:S,n:S)
 ordered(cons(m:S,cons(n:S,l:S))) -> ordered(cons(n:S,l:S)) | lte(m:S,n:S) ->* ttrue
 ordered(cons(m:S,cons(n:S,l:S))) -> ffalse | lte(m:S,n:S) ->* ffalse
 ordered(cons(m:S,nil)) -> ttrue
 ordered(nil) -> ttrue


The problem is decomposed in 2 subproblems.

Problem 1.1: 

SCC Processor:
-> Pairs:
 INSERT(cons(n:S,l:S),m:S) -> INSERT(l:S,m:S) | lte(m:S,n:S) ->* ffalse
 LTE(s(m:S),s(n:S)) -> LTE(m:S,n:S)
 ORDERED(cons(m:S,cons(n:S,l:S))) -> ORDERED(cons(n:S,l:S)) | lte(m:S,n:S) ->* ttrue
-> QPairs:
 Empty
-> Rules:
 insert(cons(n:S,l:S),m:S) -> cons(m:S,cons(n:S,l:S)) | lte(m:S,n:S) ->* ttrue
 insert(cons(n:S,l:S),m:S) -> cons(n:S,insert(l:S,m:S)) | lte(m:S,n:S) ->* ffalse
 insert(nil,m:S) -> cons(m:S,nil)
 lte(0,n:S) -> ttrue
 lte(s(m:S),0) -> ffalse
 lte(s(m:S),s(n:S)) -> lte(m:S,n:S)
 ordered(cons(m:S,cons(n:S,l:S))) -> ordered(cons(n:S,l:S)) | lte(m:S,n:S) ->* ttrue
 ordered(cons(m:S,cons(n:S,l:S))) -> ffalse | lte(m:S,n:S) ->* ffalse
 ordered(cons(m:S,nil)) -> ttrue
 ordered(nil) -> ttrue
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 ORDERED(cons(m:S,cons(n:S,l:S))) -> ORDERED(cons(n:S,l:S)) | lte(m:S,n:S) ->* ttrue
-> QPairs:
 Empty
->->-> Rules:
 insert(cons(n:S,l:S),m:S) -> cons(m:S,cons(n:S,l:S)) | lte(m:S,n:S) ->* ttrue
 insert(cons(n:S,l:S),m:S) -> cons(n:S,insert(l:S,m:S)) | lte(m:S,n:S) ->* ffalse
 insert(nil,m:S) -> cons(m:S,nil)
 lte(0,n:S) -> ttrue
 lte(s(m:S),0) -> ffalse
 lte(s(m:S),s(n:S)) -> lte(m:S,n:S)
 ordered(cons(m:S,cons(n:S,l:S))) -> ordered(cons(n:S,l:S)) | lte(m:S,n:S) ->* ttrue
 ordered(cons(m:S,cons(n:S,l:S))) -> ffalse | lte(m:S,n:S) ->* ffalse
 ordered(cons(m:S,nil)) -> ttrue
 ordered(nil) -> ttrue
->->Cycle:
->->-> Pairs:
 LTE(s(m:S),s(n:S)) -> LTE(m:S,n:S)
-> QPairs:
 Empty
->->-> Rules:
 insert(cons(n:S,l:S),m:S) -> cons(m:S,cons(n:S,l:S)) | lte(m:S,n:S) ->* ttrue
 insert(cons(n:S,l:S),m:S) -> cons(n:S,insert(l:S,m:S)) | lte(m:S,n:S) ->* ffalse
 insert(nil,m:S) -> cons(m:S,nil)
 lte(0,n:S) -> ttrue
 lte(s(m:S),0) -> ffalse
 lte(s(m:S),s(n:S)) -> lte(m:S,n:S)
 ordered(cons(m:S,cons(n:S,l:S))) -> ordered(cons(n:S,l:S)) | lte(m:S,n:S) ->* ttrue
 ordered(cons(m:S,cons(n:S,l:S))) -> ffalse | lte(m:S,n:S) ->* ffalse
 ordered(cons(m:S,nil)) -> ttrue
 ordered(nil) -> ttrue
->->Cycle:
->->-> Pairs:
 INSERT(cons(n:S,l:S),m:S) -> INSERT(l:S,m:S) | lte(m:S,n:S) ->* ffalse
-> QPairs:
 Empty
->->-> Rules:
 insert(cons(n:S,l:S),m:S) -> cons(m:S,cons(n:S,l:S)) | lte(m:S,n:S) ->* ttrue
 insert(cons(n:S,l:S),m:S) -> cons(n:S,insert(l:S,m:S)) | lte(m:S,n:S) ->* ffalse
 insert(nil,m:S) -> cons(m:S,nil)
 lte(0,n:S) -> ttrue
 lte(s(m:S),0) -> ffalse
 lte(s(m:S),s(n:S)) -> lte(m:S,n:S)
 ordered(cons(m:S,cons(n:S,l:S))) -> ordered(cons(n:S,l:S)) | lte(m:S,n:S) ->* ttrue
 ordered(cons(m:S,cons(n:S,l:S))) -> ffalse | lte(m:S,n:S) ->* ffalse
 ordered(cons(m:S,nil)) -> ttrue
 ordered(nil) -> ttrue


The problem is decomposed in 3 subproblems.

Problem 1.1.1: 

Conditional Subterm Processor:
-> Pairs:
 ORDERED(cons(m:S,cons(n:S,l:S))) -> ORDERED(cons(n:S,l:S)) | lte(m:S,n:S) ->* ttrue
-> QPairs:
 Empty
-> Rules:
 insert(cons(n:S,l:S),m:S) -> cons(m:S,cons(n:S,l:S)) | lte(m:S,n:S) ->* ttrue
 insert(cons(n:S,l:S),m:S) -> cons(n:S,insert(l:S,m:S)) | lte(m:S,n:S) ->* ffalse
 insert(nil,m:S) -> cons(m:S,nil)
 lte(0,n:S) -> ttrue
 lte(s(m:S),0) -> ffalse
 lte(s(m:S),s(n:S)) -> lte(m:S,n:S)
 ordered(cons(m:S,cons(n:S,l:S))) -> ordered(cons(n:S,l:S)) | lte(m:S,n:S) ->* ttrue
 ordered(cons(m:S,cons(n:S,l:S))) -> ffalse | lte(m:S,n:S) ->* ffalse
 ordered(cons(m:S,nil)) -> ttrue
 ordered(nil) -> ttrue
->Projection:
 pi(ORDERED) = 1

Problem 1.1.1: 

SCC Processor:
-> Pairs:
 Empty
-> QPairs:
 Empty
-> Rules:
 insert(cons(n:S,l:S),m:S) -> cons(m:S,cons(n:S,l:S)) | lte(m:S,n:S) ->* ttrue
 insert(cons(n:S,l:S),m:S) -> cons(n:S,insert(l:S,m:S)) | lte(m:S,n:S) ->* ffalse
 insert(nil,m:S) -> cons(m:S,nil)
 lte(0,n:S) -> ttrue
 lte(s(m:S),0) -> ffalse
 lte(s(m:S),s(n:S)) -> lte(m:S,n:S)
 ordered(cons(m:S,cons(n:S,l:S))) -> ordered(cons(n:S,l:S)) | lte(m:S,n:S) ->* ttrue
 ordered(cons(m:S,cons(n:S,l:S))) -> ffalse | lte(m:S,n:S) ->* ffalse
 ordered(cons(m:S,nil)) -> ttrue
 ordered(nil) -> ttrue
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.

Problem 1.1.2: 

Conditional Subterm Processor:
-> Pairs:
 LTE(s(m:S),s(n:S)) -> LTE(m:S,n:S)
-> QPairs:
 Empty
-> Rules:
 insert(cons(n:S,l:S),m:S) -> cons(m:S,cons(n:S,l:S)) | lte(m:S,n:S) ->* ttrue
 insert(cons(n:S,l:S),m:S) -> cons(n:S,insert(l:S,m:S)) | lte(m:S,n:S) ->* ffalse
 insert(nil,m:S) -> cons(m:S,nil)
 lte(0,n:S) -> ttrue
 lte(s(m:S),0) -> ffalse
 lte(s(m:S),s(n:S)) -> lte(m:S,n:S)
 ordered(cons(m:S,cons(n:S,l:S))) -> ordered(cons(n:S,l:S)) | lte(m:S,n:S) ->* ttrue
 ordered(cons(m:S,cons(n:S,l:S))) -> ffalse | lte(m:S,n:S) ->* ffalse
 ordered(cons(m:S,nil)) -> ttrue
 ordered(nil) -> ttrue
->Projection:
 pi(LTE) = 1

Problem 1.1.2: 

SCC Processor:
-> Pairs:
 Empty
-> QPairs:
 Empty
-> Rules:
 insert(cons(n:S,l:S),m:S) -> cons(m:S,cons(n:S,l:S)) | lte(m:S,n:S) ->* ttrue
 insert(cons(n:S,l:S),m:S) -> cons(n:S,insert(l:S,m:S)) | lte(m:S,n:S) ->* ffalse
 insert(nil,m:S) -> cons(m:S,nil)
 lte(0,n:S) -> ttrue
 lte(s(m:S),0) -> ffalse
 lte(s(m:S),s(n:S)) -> lte(m:S,n:S)
 ordered(cons(m:S,cons(n:S,l:S))) -> ordered(cons(n:S,l:S)) | lte(m:S,n:S) ->* ttrue
 ordered(cons(m:S,cons(n:S,l:S))) -> ffalse | lte(m:S,n:S) ->* ffalse
 ordered(cons(m:S,nil)) -> ttrue
 ordered(nil) -> ttrue
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.

Problem 1.1.3: 

Conditional Subterm Processor:
-> Pairs:
 INSERT(cons(n:S,l:S),m:S) -> INSERT(l:S,m:S) | lte(m:S,n:S) ->* ffalse
-> QPairs:
 Empty
-> Rules:
 insert(cons(n:S,l:S),m:S) -> cons(m:S,cons(n:S,l:S)) | lte(m:S,n:S) ->* ttrue
 insert(cons(n:S,l:S),m:S) -> cons(n:S,insert(l:S,m:S)) | lte(m:S,n:S) ->* ffalse
 insert(nil,m:S) -> cons(m:S,nil)
 lte(0,n:S) -> ttrue
 lte(s(m:S),0) -> ffalse
 lte(s(m:S),s(n:S)) -> lte(m:S,n:S)
 ordered(cons(m:S,cons(n:S,l:S))) -> ordered(cons(n:S,l:S)) | lte(m:S,n:S) ->* ttrue
 ordered(cons(m:S,cons(n:S,l:S))) -> ffalse | lte(m:S,n:S) ->* ffalse
 ordered(cons(m:S,nil)) -> ttrue
 ordered(nil) -> ttrue
->Projection:
 pi(INSERT) = 1

Problem 1.1.3: 

SCC Processor:
-> Pairs:
 Empty
-> QPairs:
 Empty
-> Rules:
 insert(cons(n:S,l:S),m:S) -> cons(m:S,cons(n:S,l:S)) | lte(m:S,n:S) ->* ttrue
 insert(cons(n:S,l:S),m:S) -> cons(n:S,insert(l:S,m:S)) | lte(m:S,n:S) ->* ffalse
 insert(nil,m:S) -> cons(m:S,nil)
 lte(0,n:S) -> ttrue
 lte(s(m:S),0) -> ffalse
 lte(s(m:S),s(n:S)) -> lte(m:S,n:S)
 ordered(cons(m:S,cons(n:S,l:S))) -> ordered(cons(n:S,l:S)) | lte(m:S,n:S) ->* ttrue
 ordered(cons(m:S,cons(n:S,l:S))) -> ffalse | lte(m:S,n:S) ->* ffalse
 ordered(cons(m:S,nil)) -> ttrue
 ordered(nil) -> ttrue
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.

Problem 1.2: 

SCC Processor:
-> Pairs:
 INSERT(cons(n:S,l:S),m:S) -> LTE(m:S,n:S)
 ORDERED(cons(m:S,cons(n:S,l:S))) -> LTE(m:S,n:S)
-> QPairs:
 LTE(s(m:S),s(n:S)) -> LTE(m:S,n:S)
-> Rules:
 insert(cons(n:S,l:S),m:S) -> cons(m:S,cons(n:S,l:S)) | lte(m:S,n:S) ->* ttrue
 insert(cons(n:S,l:S),m:S) -> cons(n:S,insert(l:S,m:S)) | lte(m:S,n:S) ->* ffalse
 insert(nil,m:S) -> cons(m:S,nil)
 lte(0,n:S) -> ttrue
 lte(s(m:S),0) -> ffalse
 lte(s(m:S),s(n:S)) -> lte(m:S,n:S)
 ordered(cons(m:S,cons(n:S,l:S))) -> ordered(cons(n:S,l:S)) | lte(m:S,n:S) ->* ttrue
 ordered(cons(m:S,cons(n:S,l:S))) -> ffalse | lte(m:S,n:S) ->* ffalse
 ordered(cons(m:S,nil)) -> ttrue
 ordered(nil) -> ttrue
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.