MAYBE We are left with following problem, upon which TcT provides the certificate MAYBE. Strict Trs: { eq(0(), 0()) -> true() , eq(0(), s(x)) -> false() , eq(s(x), 0()) -> false() , eq(s(x), s(y)) -> eq(x, y) , le(0(), y) -> true() , le(s(x), 0()) -> false() , le(s(x), s(y)) -> le(x, y) , app(nil(), y) -> y , app(add(n, x), y) -> add(n, app(x, y)) , min(nil()) -> 0() , min(add(n, x)) -> minIter(add(n, x), add(n, x), 0()) , minIter(nil(), add(n, y), m) -> minIter(add(n, y), add(n, y), s(m)) , minIter(add(n, x), y, m) -> if_min(le(n, m), x, y, m) , if_min(true(), x, y, m) -> m , if_min(false(), x, y, m) -> minIter(x, y, m) , head(add(n, x)) -> n , tail(nil()) -> nil() , tail(add(n, x)) -> x , null(nil()) -> true() , null(add(n, x)) -> false() , rm(n, nil()) -> nil() , rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x)) , if_rm(true(), n, add(m, x)) -> rm(n, x) , if_rm(false(), n, add(m, x)) -> add(m, rm(n, x)) , minsort(nil(), nil()) -> nil() , minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y) , if_minsort(true(), add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil())) , if_minsort(false(), add(n, x), y) -> minsort(x, add(n, y)) } Obligation: runtime complexity Answer: MAYBE None of the processors succeeded. Details of failed attempt(s): ----------------------------- 1) 'WithProblem (timeout of 60 seconds)' failed due to the following reason: Computation stopped due to timeout after 60.0 seconds. 2) 'Best' failed due to the following reason: None of the processors succeeded. Details of failed attempt(s): ----------------------------- 1) 'WithProblem (timeout of 30 seconds) (timeout of 60 seconds)' failed due to the following reason: Computation stopped due to timeout after 30.0 seconds. 2) 'Best' failed due to the following reason: None of the processors succeeded. Details of failed attempt(s): ----------------------------- 1) 'bsearch-popstar (timeout of 60 seconds)' failed due to the following reason: The processor is inapplicable, reason: Processor only applicable for innermost runtime complexity analysis 2) 'Polynomial Path Order (PS) (timeout of 60 seconds)' failed due to the following reason: The processor is inapplicable, reason: Processor only applicable for innermost runtime complexity analysis 3) 'Fastest (timeout of 5 seconds) (timeout of 60 seconds)' failed due to the following reason: None of the processors succeeded. Details of failed attempt(s): ----------------------------- 1) 'Bounds with minimal-enrichment and initial automaton 'match'' failed due to the following reason: match-boundness of the problem could not be verified. 2) 'Bounds with perSymbol-enrichment and initial automaton 'match'' failed due to the following reason: match-boundness of the problem could not be verified. 3) 'Innermost Weak Dependency Pairs (timeout of 60 seconds)' failed due to the following reason: We add the following weak dependency pairs: Strict DPs: { eq^#(0(), 0()) -> c_1() , eq^#(0(), s(x)) -> c_2() , eq^#(s(x), 0()) -> c_3() , eq^#(s(x), s(y)) -> c_4(eq^#(x, y)) , le^#(0(), y) -> c_5() , le^#(s(x), 0()) -> c_6() , le^#(s(x), s(y)) -> c_7(le^#(x, y)) , app^#(nil(), y) -> c_8(y) , app^#(add(n, x), y) -> c_9(n, app^#(x, y)) , min^#(nil()) -> c_10() , min^#(add(n, x)) -> c_11(minIter^#(add(n, x), add(n, x), 0())) , minIter^#(nil(), add(n, y), m) -> c_12(minIter^#(add(n, y), add(n, y), s(m))) , minIter^#(add(n, x), y, m) -> c_13(if_min^#(le(n, m), x, y, m)) , if_min^#(true(), x, y, m) -> c_14(m) , if_min^#(false(), x, y, m) -> c_15(minIter^#(x, y, m)) , head^#(add(n, x)) -> c_16(n) , tail^#(nil()) -> c_17() , tail^#(add(n, x)) -> c_18(x) , null^#(nil()) -> c_19() , null^#(add(n, x)) -> c_20() , rm^#(n, nil()) -> c_21() , rm^#(n, add(m, x)) -> c_22(if_rm^#(eq(n, m), n, add(m, x))) , if_rm^#(true(), n, add(m, x)) -> c_23(rm^#(n, x)) , if_rm^#(false(), n, add(m, x)) -> c_24(m, rm^#(n, x)) , minsort^#(nil(), nil()) -> c_25() , minsort^#(add(n, x), y) -> c_26(if_minsort^#(eq(n, min(add(n, x))), add(n, x), y)) , if_minsort^#(true(), add(n, x), y) -> c_27(n, minsort^#(app(rm(n, x), y), nil())) , if_minsort^#(false(), add(n, x), y) -> c_28(minsort^#(x, add(n, y))) } and mark the set of starting terms. We are left with following problem, upon which TcT provides the certificate MAYBE. Strict DPs: { eq^#(0(), 0()) -> c_1() , eq^#(0(), s(x)) -> c_2() , eq^#(s(x), 0()) -> c_3() , eq^#(s(x), s(y)) -> c_4(eq^#(x, y)) , le^#(0(), y) -> c_5() , le^#(s(x), 0()) -> c_6() , le^#(s(x), s(y)) -> c_7(le^#(x, y)) , app^#(nil(), y) -> c_8(y) , app^#(add(n, x), y) -> c_9(n, app^#(x, y)) , min^#(nil()) -> c_10() , min^#(add(n, x)) -> c_11(minIter^#(add(n, x), add(n, x), 0())) , minIter^#(nil(), add(n, y), m) -> c_12(minIter^#(add(n, y), add(n, y), s(m))) , minIter^#(add(n, x), y, m) -> c_13(if_min^#(le(n, m), x, y, m)) , if_min^#(true(), x, y, m) -> c_14(m) , if_min^#(false(), x, y, m) -> c_15(minIter^#(x, y, m)) , head^#(add(n, x)) -> c_16(n) , tail^#(nil()) -> c_17() , tail^#(add(n, x)) -> c_18(x) , null^#(nil()) -> c_19() , null^#(add(n, x)) -> c_20() , rm^#(n, nil()) -> c_21() , rm^#(n, add(m, x)) -> c_22(if_rm^#(eq(n, m), n, add(m, x))) , if_rm^#(true(), n, add(m, x)) -> c_23(rm^#(n, x)) , if_rm^#(false(), n, add(m, x)) -> c_24(m, rm^#(n, x)) , minsort^#(nil(), nil()) -> c_25() , minsort^#(add(n, x), y) -> c_26(if_minsort^#(eq(n, min(add(n, x))), add(n, x), y)) , if_minsort^#(true(), add(n, x), y) -> c_27(n, minsort^#(app(rm(n, x), y), nil())) , if_minsort^#(false(), add(n, x), y) -> c_28(minsort^#(x, add(n, y))) } Strict Trs: { eq(0(), 0()) -> true() , eq(0(), s(x)) -> false() , eq(s(x), 0()) -> false() , eq(s(x), s(y)) -> eq(x, y) , le(0(), y) -> true() , le(s(x), 0()) -> false() , le(s(x), s(y)) -> le(x, y) , app(nil(), y) -> y , app(add(n, x), y) -> add(n, app(x, y)) , min(nil()) -> 0() , min(add(n, x)) -> minIter(add(n, x), add(n, x), 0()) , minIter(nil(), add(n, y), m) -> minIter(add(n, y), add(n, y), s(m)) , minIter(add(n, x), y, m) -> if_min(le(n, m), x, y, m) , if_min(true(), x, y, m) -> m , if_min(false(), x, y, m) -> minIter(x, y, m) , head(add(n, x)) -> n , tail(nil()) -> nil() , tail(add(n, x)) -> x , null(nil()) -> true() , null(add(n, x)) -> false() , rm(n, nil()) -> nil() , rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x)) , if_rm(true(), n, add(m, x)) -> rm(n, x) , if_rm(false(), n, add(m, x)) -> add(m, rm(n, x)) , minsort(nil(), nil()) -> nil() , minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y) , if_minsort(true(), add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil())) , if_minsort(false(), add(n, x), y) -> minsort(x, add(n, y)) } Obligation: runtime complexity Answer: MAYBE We estimate the number of application of {1,2,3,5,6,10,17,19,20,21,25} by applications of Pre({1,2,3,5,6,10,17,19,20,21,25}) = {4,7,8,9,14,16,18,23,24,27}. Here rules are labeled as follows: DPs: { 1: eq^#(0(), 0()) -> c_1() , 2: eq^#(0(), s(x)) -> c_2() , 3: eq^#(s(x), 0()) -> c_3() , 4: eq^#(s(x), s(y)) -> c_4(eq^#(x, y)) , 5: le^#(0(), y) -> c_5() , 6: le^#(s(x), 0()) -> c_6() , 7: le^#(s(x), s(y)) -> c_7(le^#(x, y)) , 8: app^#(nil(), y) -> c_8(y) , 9: app^#(add(n, x), y) -> c_9(n, app^#(x, y)) , 10: min^#(nil()) -> c_10() , 11: min^#(add(n, x)) -> c_11(minIter^#(add(n, x), add(n, x), 0())) , 12: minIter^#(nil(), add(n, y), m) -> c_12(minIter^#(add(n, y), add(n, y), s(m))) , 13: minIter^#(add(n, x), y, m) -> c_13(if_min^#(le(n, m), x, y, m)) , 14: if_min^#(true(), x, y, m) -> c_14(m) , 15: if_min^#(false(), x, y, m) -> c_15(minIter^#(x, y, m)) , 16: head^#(add(n, x)) -> c_16(n) , 17: tail^#(nil()) -> c_17() , 18: tail^#(add(n, x)) -> c_18(x) , 19: null^#(nil()) -> c_19() , 20: null^#(add(n, x)) -> c_20() , 21: rm^#(n, nil()) -> c_21() , 22: rm^#(n, add(m, x)) -> c_22(if_rm^#(eq(n, m), n, add(m, x))) , 23: if_rm^#(true(), n, add(m, x)) -> c_23(rm^#(n, x)) , 24: if_rm^#(false(), n, add(m, x)) -> c_24(m, rm^#(n, x)) , 25: minsort^#(nil(), nil()) -> c_25() , 26: minsort^#(add(n, x), y) -> c_26(if_minsort^#(eq(n, min(add(n, x))), add(n, x), y)) , 27: if_minsort^#(true(), add(n, x), y) -> c_27(n, minsort^#(app(rm(n, x), y), nil())) , 28: if_minsort^#(false(), add(n, x), y) -> c_28(minsort^#(x, add(n, y))) } We are left with following problem, upon which TcT provides the certificate MAYBE. Strict DPs: { eq^#(s(x), s(y)) -> c_4(eq^#(x, y)) , le^#(s(x), s(y)) -> c_7(le^#(x, y)) , app^#(nil(), y) -> c_8(y) , app^#(add(n, x), y) -> c_9(n, app^#(x, y)) , min^#(add(n, x)) -> c_11(minIter^#(add(n, x), add(n, x), 0())) , minIter^#(nil(), add(n, y), m) -> c_12(minIter^#(add(n, y), add(n, y), s(m))) , minIter^#(add(n, x), y, m) -> c_13(if_min^#(le(n, m), x, y, m)) , if_min^#(true(), x, y, m) -> c_14(m) , if_min^#(false(), x, y, m) -> c_15(minIter^#(x, y, m)) , head^#(add(n, x)) -> c_16(n) , tail^#(add(n, x)) -> c_18(x) , rm^#(n, add(m, x)) -> c_22(if_rm^#(eq(n, m), n, add(m, x))) , if_rm^#(true(), n, add(m, x)) -> c_23(rm^#(n, x)) , if_rm^#(false(), n, add(m, x)) -> c_24(m, rm^#(n, x)) , minsort^#(add(n, x), y) -> c_26(if_minsort^#(eq(n, min(add(n, x))), add(n, x), y)) , if_minsort^#(true(), add(n, x), y) -> c_27(n, minsort^#(app(rm(n, x), y), nil())) , if_minsort^#(false(), add(n, x), y) -> c_28(minsort^#(x, add(n, y))) } Strict Trs: { eq(0(), 0()) -> true() , eq(0(), s(x)) -> false() , eq(s(x), 0()) -> false() , eq(s(x), s(y)) -> eq(x, y) , le(0(), y) -> true() , le(s(x), 0()) -> false() , le(s(x), s(y)) -> le(x, y) , app(nil(), y) -> y , app(add(n, x), y) -> add(n, app(x, y)) , min(nil()) -> 0() , min(add(n, x)) -> minIter(add(n, x), add(n, x), 0()) , minIter(nil(), add(n, y), m) -> minIter(add(n, y), add(n, y), s(m)) , minIter(add(n, x), y, m) -> if_min(le(n, m), x, y, m) , if_min(true(), x, y, m) -> m , if_min(false(), x, y, m) -> minIter(x, y, m) , head(add(n, x)) -> n , tail(nil()) -> nil() , tail(add(n, x)) -> x , null(nil()) -> true() , null(add(n, x)) -> false() , rm(n, nil()) -> nil() , rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x)) , if_rm(true(), n, add(m, x)) -> rm(n, x) , if_rm(false(), n, add(m, x)) -> add(m, rm(n, x)) , minsort(nil(), nil()) -> nil() , minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y) , if_minsort(true(), add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil())) , if_minsort(false(), add(n, x), y) -> minsort(x, add(n, y)) } Weak DPs: { eq^#(0(), 0()) -> c_1() , eq^#(0(), s(x)) -> c_2() , eq^#(s(x), 0()) -> c_3() , le^#(0(), y) -> c_5() , le^#(s(x), 0()) -> c_6() , min^#(nil()) -> c_10() , tail^#(nil()) -> c_17() , null^#(nil()) -> c_19() , null^#(add(n, x)) -> c_20() , rm^#(n, nil()) -> c_21() , minsort^#(nil(), nil()) -> c_25() } Obligation: runtime complexity Answer: MAYBE Empty strict component of the problem is NOT empty. Arrrr..