MAYBE

We are left with following problem, upon which TcT provides the
certificate MAYBE.

Strict Trs:
  { max(nil()) -> 0()
  , max(cons(x, nil())) -> x
  , max(cons(x, cons(y, xs))) -> if1(ge(x, y), x, y, xs)
  , if1(true(), x, y, xs) -> max(cons(x, xs))
  , if1(false(), x, y, xs) -> max(cons(y, xs))
  , ge(x, 0()) -> true()
  , ge(0(), s(x)) -> false()
  , ge(s(x), s(y)) -> ge(x, y)
  , del(x, nil()) -> nil()
  , del(x, cons(y, xs)) -> if2(eq(x, y), x, y, xs)
  , if2(true(), x, y, xs) -> xs
  , if2(false(), x, y, xs) -> cons(y, del(x, xs))
  , eq(0(), 0()) -> true()
  , eq(0(), s(y)) -> false()
  , eq(s(x), 0()) -> false()
  , eq(s(x), s(y)) -> eq(x, y)
  , sort(nil()) -> nil()
  , sort(cons(x, xs)) ->
    cons(max(cons(x, xs)), sort(del(max(cons(x, xs)), cons(x, xs)))) }
Obligation:
  innermost runtime complexity
Answer:
  MAYBE

We add following dependency tuples:

Strict DPs:
  { max^#(nil()) -> c_1()
  , max^#(cons(x, nil())) -> c_2()
  , max^#(cons(x, cons(y, xs))) ->
    c_3(if1^#(ge(x, y), x, y, xs), ge^#(x, y))
  , if1^#(true(), x, y, xs) -> c_4(max^#(cons(x, xs)))
  , if1^#(false(), x, y, xs) -> c_5(max^#(cons(y, xs)))
  , ge^#(x, 0()) -> c_6()
  , ge^#(0(), s(x)) -> c_7()
  , ge^#(s(x), s(y)) -> c_8(ge^#(x, y))
  , del^#(x, nil()) -> c_9()
  , del^#(x, cons(y, xs)) ->
    c_10(if2^#(eq(x, y), x, y, xs), eq^#(x, y))
  , if2^#(true(), x, y, xs) -> c_11()
  , if2^#(false(), x, y, xs) -> c_12(del^#(x, xs))
  , eq^#(0(), 0()) -> c_13()
  , eq^#(0(), s(y)) -> c_14()
  , eq^#(s(x), 0()) -> c_15()
  , eq^#(s(x), s(y)) -> c_16(eq^#(x, y))
  , sort^#(nil()) -> c_17()
  , sort^#(cons(x, xs)) ->
    c_18(max^#(cons(x, xs)),
         sort^#(del(max(cons(x, xs)), cons(x, xs))),
         del^#(max(cons(x, xs)), cons(x, xs)),
         max^#(cons(x, xs))) }

and mark the set of starting terms.

We are left with following problem, upon which TcT provides the
certificate MAYBE.

Strict DPs:
  { max^#(nil()) -> c_1()
  , max^#(cons(x, nil())) -> c_2()
  , max^#(cons(x, cons(y, xs))) ->
    c_3(if1^#(ge(x, y), x, y, xs), ge^#(x, y))
  , if1^#(true(), x, y, xs) -> c_4(max^#(cons(x, xs)))
  , if1^#(false(), x, y, xs) -> c_5(max^#(cons(y, xs)))
  , ge^#(x, 0()) -> c_6()
  , ge^#(0(), s(x)) -> c_7()
  , ge^#(s(x), s(y)) -> c_8(ge^#(x, y))
  , del^#(x, nil()) -> c_9()
  , del^#(x, cons(y, xs)) ->
    c_10(if2^#(eq(x, y), x, y, xs), eq^#(x, y))
  , if2^#(true(), x, y, xs) -> c_11()
  , if2^#(false(), x, y, xs) -> c_12(del^#(x, xs))
  , eq^#(0(), 0()) -> c_13()
  , eq^#(0(), s(y)) -> c_14()
  , eq^#(s(x), 0()) -> c_15()
  , eq^#(s(x), s(y)) -> c_16(eq^#(x, y))
  , sort^#(nil()) -> c_17()
  , sort^#(cons(x, xs)) ->
    c_18(max^#(cons(x, xs)),
         sort^#(del(max(cons(x, xs)), cons(x, xs))),
         del^#(max(cons(x, xs)), cons(x, xs)),
         max^#(cons(x, xs))) }
Weak Trs:
  { max(nil()) -> 0()
  , max(cons(x, nil())) -> x
  , max(cons(x, cons(y, xs))) -> if1(ge(x, y), x, y, xs)
  , if1(true(), x, y, xs) -> max(cons(x, xs))
  , if1(false(), x, y, xs) -> max(cons(y, xs))
  , ge(x, 0()) -> true()
  , ge(0(), s(x)) -> false()
  , ge(s(x), s(y)) -> ge(x, y)
  , del(x, nil()) -> nil()
  , del(x, cons(y, xs)) -> if2(eq(x, y), x, y, xs)
  , if2(true(), x, y, xs) -> xs
  , if2(false(), x, y, xs) -> cons(y, del(x, xs))
  , eq(0(), 0()) -> true()
  , eq(0(), s(y)) -> false()
  , eq(s(x), 0()) -> false()
  , eq(s(x), s(y)) -> eq(x, y)
  , sort(nil()) -> nil()
  , sort(cons(x, xs)) ->
    cons(max(cons(x, xs)), sort(del(max(cons(x, xs)), cons(x, xs)))) }
Obligation:
  innermost runtime complexity
Answer:
  MAYBE

We estimate the number of application of {1,2,6,7,9,11,13,14,15,17}
by applications of Pre({1,2,6,7,9,11,13,14,15,17}) =
{3,4,5,8,10,12,16,18}. Here rules are labeled as follows:

  DPs:
    { 1: max^#(nil()) -> c_1()
    , 2: max^#(cons(x, nil())) -> c_2()
    , 3: max^#(cons(x, cons(y, xs))) ->
         c_3(if1^#(ge(x, y), x, y, xs), ge^#(x, y))
    , 4: if1^#(true(), x, y, xs) -> c_4(max^#(cons(x, xs)))
    , 5: if1^#(false(), x, y, xs) -> c_5(max^#(cons(y, xs)))
    , 6: ge^#(x, 0()) -> c_6()
    , 7: ge^#(0(), s(x)) -> c_7()
    , 8: ge^#(s(x), s(y)) -> c_8(ge^#(x, y))
    , 9: del^#(x, nil()) -> c_9()
    , 10: del^#(x, cons(y, xs)) ->
          c_10(if2^#(eq(x, y), x, y, xs), eq^#(x, y))
    , 11: if2^#(true(), x, y, xs) -> c_11()
    , 12: if2^#(false(), x, y, xs) -> c_12(del^#(x, xs))
    , 13: eq^#(0(), 0()) -> c_13()
    , 14: eq^#(0(), s(y)) -> c_14()
    , 15: eq^#(s(x), 0()) -> c_15()
    , 16: eq^#(s(x), s(y)) -> c_16(eq^#(x, y))
    , 17: sort^#(nil()) -> c_17()
    , 18: sort^#(cons(x, xs)) ->
          c_18(max^#(cons(x, xs)),
               sort^#(del(max(cons(x, xs)), cons(x, xs))),
               del^#(max(cons(x, xs)), cons(x, xs)),
               max^#(cons(x, xs))) }

We are left with following problem, upon which TcT provides the
certificate MAYBE.

Strict DPs:
  { max^#(cons(x, cons(y, xs))) ->
    c_3(if1^#(ge(x, y), x, y, xs), ge^#(x, y))
  , if1^#(true(), x, y, xs) -> c_4(max^#(cons(x, xs)))
  , if1^#(false(), x, y, xs) -> c_5(max^#(cons(y, xs)))
  , ge^#(s(x), s(y)) -> c_8(ge^#(x, y))
  , del^#(x, cons(y, xs)) ->
    c_10(if2^#(eq(x, y), x, y, xs), eq^#(x, y))
  , if2^#(false(), x, y, xs) -> c_12(del^#(x, xs))
  , eq^#(s(x), s(y)) -> c_16(eq^#(x, y))
  , sort^#(cons(x, xs)) ->
    c_18(max^#(cons(x, xs)),
         sort^#(del(max(cons(x, xs)), cons(x, xs))),
         del^#(max(cons(x, xs)), cons(x, xs)),
         max^#(cons(x, xs))) }
Weak DPs:
  { max^#(nil()) -> c_1()
  , max^#(cons(x, nil())) -> c_2()
  , ge^#(x, 0()) -> c_6()
  , ge^#(0(), s(x)) -> c_7()
  , del^#(x, nil()) -> c_9()
  , if2^#(true(), x, y, xs) -> c_11()
  , eq^#(0(), 0()) -> c_13()
  , eq^#(0(), s(y)) -> c_14()
  , eq^#(s(x), 0()) -> c_15()
  , sort^#(nil()) -> c_17() }
Weak Trs:
  { max(nil()) -> 0()
  , max(cons(x, nil())) -> x
  , max(cons(x, cons(y, xs))) -> if1(ge(x, y), x, y, xs)
  , if1(true(), x, y, xs) -> max(cons(x, xs))
  , if1(false(), x, y, xs) -> max(cons(y, xs))
  , ge(x, 0()) -> true()
  , ge(0(), s(x)) -> false()
  , ge(s(x), s(y)) -> ge(x, y)
  , del(x, nil()) -> nil()
  , del(x, cons(y, xs)) -> if2(eq(x, y), x, y, xs)
  , if2(true(), x, y, xs) -> xs
  , if2(false(), x, y, xs) -> cons(y, del(x, xs))
  , eq(0(), 0()) -> true()
  , eq(0(), s(y)) -> false()
  , eq(s(x), 0()) -> false()
  , eq(s(x), s(y)) -> eq(x, y)
  , sort(nil()) -> nil()
  , sort(cons(x, xs)) ->
    cons(max(cons(x, xs)), sort(del(max(cons(x, xs)), cons(x, xs)))) }
Obligation:
  innermost runtime complexity
Answer:
  MAYBE

The following weak DPs constitute a sub-graph of the DG that is
closed under successors. The DPs are removed.

{ max^#(nil()) -> c_1()
, max^#(cons(x, nil())) -> c_2()
, ge^#(x, 0()) -> c_6()
, ge^#(0(), s(x)) -> c_7()
, del^#(x, nil()) -> c_9()
, if2^#(true(), x, y, xs) -> c_11()
, eq^#(0(), 0()) -> c_13()
, eq^#(0(), s(y)) -> c_14()
, eq^#(s(x), 0()) -> c_15()
, sort^#(nil()) -> c_17() }

We are left with following problem, upon which TcT provides the
certificate MAYBE.

Strict DPs:
  { max^#(cons(x, cons(y, xs))) ->
    c_3(if1^#(ge(x, y), x, y, xs), ge^#(x, y))
  , if1^#(true(), x, y, xs) -> c_4(max^#(cons(x, xs)))
  , if1^#(false(), x, y, xs) -> c_5(max^#(cons(y, xs)))
  , ge^#(s(x), s(y)) -> c_8(ge^#(x, y))
  , del^#(x, cons(y, xs)) ->
    c_10(if2^#(eq(x, y), x, y, xs), eq^#(x, y))
  , if2^#(false(), x, y, xs) -> c_12(del^#(x, xs))
  , eq^#(s(x), s(y)) -> c_16(eq^#(x, y))
  , sort^#(cons(x, xs)) ->
    c_18(max^#(cons(x, xs)),
         sort^#(del(max(cons(x, xs)), cons(x, xs))),
         del^#(max(cons(x, xs)), cons(x, xs)),
         max^#(cons(x, xs))) }
Weak Trs:
  { max(nil()) -> 0()
  , max(cons(x, nil())) -> x
  , max(cons(x, cons(y, xs))) -> if1(ge(x, y), x, y, xs)
  , if1(true(), x, y, xs) -> max(cons(x, xs))
  , if1(false(), x, y, xs) -> max(cons(y, xs))
  , ge(x, 0()) -> true()
  , ge(0(), s(x)) -> false()
  , ge(s(x), s(y)) -> ge(x, y)
  , del(x, nil()) -> nil()
  , del(x, cons(y, xs)) -> if2(eq(x, y), x, y, xs)
  , if2(true(), x, y, xs) -> xs
  , if2(false(), x, y, xs) -> cons(y, del(x, xs))
  , eq(0(), 0()) -> true()
  , eq(0(), s(y)) -> false()
  , eq(s(x), 0()) -> false()
  , eq(s(x), s(y)) -> eq(x, y)
  , sort(nil()) -> nil()
  , sort(cons(x, xs)) ->
    cons(max(cons(x, xs)), sort(del(max(cons(x, xs)), cons(x, xs)))) }
Obligation:
  innermost runtime complexity
Answer:
  MAYBE

We replace rewrite rules by usable rules:

  Weak Usable Rules:
    { max(nil()) -> 0()
    , max(cons(x, nil())) -> x
    , max(cons(x, cons(y, xs))) -> if1(ge(x, y), x, y, xs)
    , if1(true(), x, y, xs) -> max(cons(x, xs))
    , if1(false(), x, y, xs) -> max(cons(y, xs))
    , ge(x, 0()) -> true()
    , ge(0(), s(x)) -> false()
    , ge(s(x), s(y)) -> ge(x, y)
    , del(x, nil()) -> nil()
    , del(x, cons(y, xs)) -> if2(eq(x, y), x, y, xs)
    , if2(true(), x, y, xs) -> xs
    , if2(false(), x, y, xs) -> cons(y, del(x, xs))
    , eq(0(), 0()) -> true()
    , eq(0(), s(y)) -> false()
    , eq(s(x), 0()) -> false()
    , eq(s(x), s(y)) -> eq(x, y) }

We are left with following problem, upon which TcT provides the
certificate MAYBE.

Strict DPs:
  { max^#(cons(x, cons(y, xs))) ->
    c_3(if1^#(ge(x, y), x, y, xs), ge^#(x, y))
  , if1^#(true(), x, y, xs) -> c_4(max^#(cons(x, xs)))
  , if1^#(false(), x, y, xs) -> c_5(max^#(cons(y, xs)))
  , ge^#(s(x), s(y)) -> c_8(ge^#(x, y))
  , del^#(x, cons(y, xs)) ->
    c_10(if2^#(eq(x, y), x, y, xs), eq^#(x, y))
  , if2^#(false(), x, y, xs) -> c_12(del^#(x, xs))
  , eq^#(s(x), s(y)) -> c_16(eq^#(x, y))
  , sort^#(cons(x, xs)) ->
    c_18(max^#(cons(x, xs)),
         sort^#(del(max(cons(x, xs)), cons(x, xs))),
         del^#(max(cons(x, xs)), cons(x, xs)),
         max^#(cons(x, xs))) }
Weak Trs:
  { max(nil()) -> 0()
  , max(cons(x, nil())) -> x
  , max(cons(x, cons(y, xs))) -> if1(ge(x, y), x, y, xs)
  , if1(true(), x, y, xs) -> max(cons(x, xs))
  , if1(false(), x, y, xs) -> max(cons(y, xs))
  , ge(x, 0()) -> true()
  , ge(0(), s(x)) -> false()
  , ge(s(x), s(y)) -> ge(x, y)
  , del(x, nil()) -> nil()
  , del(x, cons(y, xs)) -> if2(eq(x, y), x, y, xs)
  , if2(true(), x, y, xs) -> xs
  , if2(false(), x, y, xs) -> cons(y, del(x, xs))
  , eq(0(), 0()) -> true()
  , eq(0(), s(y)) -> false()
  , eq(s(x), 0()) -> false()
  , eq(s(x), s(y)) -> eq(x, y) }
Obligation:
  innermost runtime complexity
Answer:
  MAYBE

The input cannot be shown compatible

Arrrr..