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


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


YES

Problem 1: 

(VAR l m n)
(RULES
insert(cons(n,l),m) -> cons(m,cons(n,l)) | lte(m,n) -> true
insert(cons(n,l),m) -> cons(n,insert(l,m)) | lte(m,n) -> false
insert(nil,m) -> cons(m,nil)
lte(0,n) -> true
lte(s(m),0) -> false
lte(s(m),s(n)) -> lte(m,n)
ordered(cons(m,cons(n,l))) -> ordered(cons(n,l)) | lte(m,n) -> true
ordered(cons(m,cons(n,l))) -> false | lte(m,n) -> false
ordered(cons(m,nil)) -> true
ordered(nil) -> true
)

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

Problem 1: 

Dependency Pairs Processor:

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

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


The problem is decomposed in 2 subproblems.

Problem 1.1: 

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


The problem is decomposed in 3 subproblems.

Problem 1.1.1: 

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

Problem 1.1.1: 

SCC Processor:
-> Pairs:
 Empty
-> QPairs:
 Empty
-> Rules:
 insert(cons(n,l),m) -> cons(m,cons(n,l)) | lte(m,n) -> true
 insert(cons(n,l),m) -> cons(n,insert(l,m)) | lte(m,n) -> false
 insert(nil,m) -> cons(m,nil)
 lte(0,n) -> true
 lte(s(m),0) -> false
 lte(s(m),s(n)) -> lte(m,n)
 ordered(cons(m,cons(n,l))) -> ordered(cons(n,l)) | lte(m,n) -> true
 ordered(cons(m,cons(n,l))) -> false | lte(m,n) -> false
 ordered(cons(m,nil)) -> true
 ordered(nil) -> true
->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(n)) -> LTE(m,n)
-> QPairs:
 Empty
-> Rules:
 insert(cons(n,l),m) -> cons(m,cons(n,l)) | lte(m,n) -> true
 insert(cons(n,l),m) -> cons(n,insert(l,m)) | lte(m,n) -> false
 insert(nil,m) -> cons(m,nil)
 lte(0,n) -> true
 lte(s(m),0) -> false
 lte(s(m),s(n)) -> lte(m,n)
 ordered(cons(m,cons(n,l))) -> ordered(cons(n,l)) | lte(m,n) -> true
 ordered(cons(m,cons(n,l))) -> false | lte(m,n) -> false
 ordered(cons(m,nil)) -> true
 ordered(nil) -> true
->Projection:
 pi(LTE) = 1

Problem 1.1.2: 

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

The problem is finite.

Problem 1.1.3: 

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

Problem 1.1.3: 

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

The problem is finite.

Problem 1.2: 

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

Problem 1.2: 

Conditional Subterm Processor:
-> Pairs:
 INSERT(cons(n,l),m) -> LTE(m,n)
 ORDERED(cons(m,cons(n,l))) -> LTE(m,n)
-> QPairs:
 INSERT(cons(n,l),m) -> INSERT(l,m) | lte(m,n) -> false
 LTE(s(m),s(n)) -> LTE(m,n)
 ORDERED(cons(m,cons(n,l))) -> ORDERED(cons(n,l)) | lte(m,n) -> true
-> Rules:
 insert(cons(n,l),m) -> cons(m,cons(n,l)) | lte(m,n) -> true
 insert(cons(n,l),m) -> cons(n,insert(l,m)) | lte(m,n) -> false
 insert(nil,m) -> cons(m,nil)
 lte(0,n) -> true
 lte(s(m),0) -> false
 lte(s(m),s(n)) -> lte(m,n)
 ordered(cons(m,cons(n,l))) -> ordered(cons(n,l)) | lte(m,n) -> true
 ordered(cons(m,cons(n,l))) -> false | lte(m,n) -> false
 ordered(cons(m,nil)) -> true
 ordered(nil) -> true
->Projection:
 pi(INSERT) = 1
 pi(LTE) = 2
 pi(ORDERED) = 1

Problem 1.2: 

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

The problem is finite.