/export/starexec/sandbox/solver/bin/starexec_run_Itrs /export/starexec/sandbox/benchmark/theBenchmark.itrs /export/starexec/sandbox/output/output_files


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


MAYBE

DP problem for innermost termination.
P =
  sort#(cons(x, xs)) -> max#(cons(x, xs)) 
  sort#(cons(x, xs)) -> sort#(del(max(cons(x, xs)), cons(x, xs))) 
  sort#(cons(x, xs)) -> del#(max(cons(x, xs)), cons(x, xs)) 
  sort#(cons(x, xs)) -> max#(cons(x, xs)) 
  if2#(false, I0, y, B0) -> del#(I0, B0) 
  del#(I3, cons(I4, B2)) -> if2#(I3 = I4, I3, I4, B2) 
  if1#(false, I6, I7, B3) -> max#(cons(I7, B3)) 
  if1#(true, I8, I9, B4) -> max#(cons(I8, B4)) 
  max#(cons(I10, cons(I11, B5))) -> if1#(I10 >= I11, I10, I11, B5) 
R = 
  sort(cons(x, xs)) -> cons(max(cons(x, xs)), sort(del(max(cons(x, xs)), cons(x, xs)))) 
  sort(nil) -> nil 
  if2(false, I0, y, B0) -> cons(y, del(I0, B0)) 
  if2(true, I1, I2, B1) -> B1 
  del(I3, cons(I4, B2)) -> if2(I3 = I4, I3, I4, B2) 
  del(I5, nil) -> nil 
  if1(false, I6, I7, B3) -> max(cons(I7, B3)) 
  if1(true, I8, I9, B4) -> max(cons(I8, B4)) 
  max(cons(I10, cons(I11, B5))) -> if1(I10 >= I11, I10, I11, B5) 
  max(cons(I12, nil)) -> I12 
  max(nil) -> 0 

This problem is converted using chaining, where edges between chained DPs are removed.

DP problem for innermost termination.
P =
  sort#(cons(x, xs)) -> max#(cons(x, xs)) 
  sort#(cons(x, xs)) -> sort#(del(max(cons(x, xs)), cons(x, xs))) 
  sort#(cons(x, xs)) -> del#(max(cons(x, xs)), cons(x, xs)) 
  sort#(cons(x, xs)) -> max#(cons(x, xs)) 
  if2#(false, I0, y, B0) -> del#(I0, B0) 
  del#(I3, cons(I4, B2)) -> if2#(I3 = I4, I3, I4, B2) 
  if1#(false, I6, I7, B3) -> max#(cons(I7, B3)) 
  if1#(true, I8, I9, B4) -> max#(cons(I8, B4)) 
  max#(cons(I10, cons(I11, B5))) -> if1#(I10 >= I11, I10, I11, B5) 
  max#(cons(I10, cons(I11, B5))) -> max#(cons(I11, B5)) [not(I10 >= I11)]
  max#(cons(I10, cons(I11, B5))) -> max#(cons(I10, B5)) [I10 >= I11]
  del#(I3, cons(I4, B2)) -> del#(I3, B2) [not(I3 = I4)]
R = 
  sort(cons(x, xs)) -> cons(max(cons(x, xs)), sort(del(max(cons(x, xs)), cons(x, xs)))) 
  sort(nil) -> nil 
  if2(false, I0, y, B0) -> cons(y, del(I0, B0)) 
  if2(true, I1, I2, B1) -> B1 
  del(I3, cons(I4, B2)) -> if2(I3 = I4, I3, I4, B2) 
  del(I5, nil) -> nil 
  if1(false, I6, I7, B3) -> max(cons(I7, B3)) 
  if1(true, I8, I9, B4) -> max(cons(I8, B4)) 
  max(cons(I10, cons(I11, B5))) -> if1(I10 >= I11, I10, I11, B5) 
  max(cons(I12, nil)) -> I12 
  max(nil) -> 0 

The dependency graph for this problem is:
  0 -> 10, 9, 8
  1 -> 0, 1, 2, 3
  2 -> 11, 5
  3 -> 10, 9, 8
  4 -> 11, 5
  5 -> 
  6 -> 10, 9, 8
  7 -> 10, 9, 8
  8 -> 
  9 -> 10, 9, 8
  10 -> 10, 8, 9
  11 -> 11, 5
Where:
  0) sort#(cons(x, xs)) -> max#(cons(x, xs)) 
  1) sort#(cons(x, xs)) -> sort#(del(max(cons(x, xs)), cons(x, xs))) 
  2) sort#(cons(x, xs)) -> del#(max(cons(x, xs)), cons(x, xs)) 
  3) sort#(cons(x, xs)) -> max#(cons(x, xs)) 
  4) if2#(false, I0, y, B0) -> del#(I0, B0) 
  5) del#(I3, cons(I4, B2)) -> if2#(I3 = I4, I3, I4, B2) 
  6) if1#(false, I6, I7, B3) -> max#(cons(I7, B3)) 
  7) if1#(true, I8, I9, B4) -> max#(cons(I8, B4)) 
  8) max#(cons(I10, cons(I11, B5))) -> if1#(I10 >= I11, I10, I11, B5) 
  9) max#(cons(I10, cons(I11, B5))) -> max#(cons(I11, B5)) [not(I10 >= I11)]
  10) max#(cons(I10, cons(I11, B5))) -> max#(cons(I10, B5)) [I10 >= I11]
  11) del#(I3, cons(I4, B2)) -> del#(I3, B2) [not(I3 = I4)]

We have the following SCCs.
  { 1 }
  { 9, 10 }
  { 11 }

DP problem for innermost termination.
P =
  del#(I3, cons(I4, B2)) -> del#(I3, B2) [not(I3 = I4)]
R = 
  sort(cons(x, xs)) -> cons(max(cons(x, xs)), sort(del(max(cons(x, xs)), cons(x, xs)))) 
  sort(nil) -> nil 
  if2(false, I0, y, B0) -> cons(y, del(I0, B0)) 
  if2(true, I1, I2, B1) -> B1 
  del(I3, cons(I4, B2)) -> if2(I3 = I4, I3, I4, B2) 
  del(I5, nil) -> nil 
  if1(false, I6, I7, B3) -> max(cons(I7, B3)) 
  if1(true, I8, I9, B4) -> max(cons(I8, B4)) 
  max(cons(I10, cons(I11, B5))) -> if1(I10 >= I11, I10, I11, B5) 
  max(cons(I12, nil)) -> I12 
  max(nil) -> 0 

We use the subterm criterion with the projection function NU:
  NU[del#(x0,x1)] = x1

This gives the following inequalities:
  cons(I4, B2) |> B2

All dependency pairs are strictly oriented, so the entire dependency pair problem may be removed.

DP problem for innermost termination.
P =
  max#(cons(I10, cons(I11, B5))) -> max#(cons(I11, B5)) [not(I10 >= I11)]
  max#(cons(I10, cons(I11, B5))) -> max#(cons(I10, B5)) [I10 >= I11]
R = 
  sort(cons(x, xs)) -> cons(max(cons(x, xs)), sort(del(max(cons(x, xs)), cons(x, xs)))) 
  sort(nil) -> nil 
  if2(false, I0, y, B0) -> cons(y, del(I0, B0)) 
  if2(true, I1, I2, B1) -> B1 
  del(I3, cons(I4, B2)) -> if2(I3 = I4, I3, I4, B2) 
  del(I5, nil) -> nil 
  if1(false, I6, I7, B3) -> max(cons(I7, B3)) 
  if1(true, I8, I9, B4) -> max(cons(I8, B4)) 
  max(cons(I10, cons(I11, B5))) -> if1(I10 >= I11, I10, I11, B5) 
  max(cons(I12, nil)) -> I12 
  max(nil) -> 0