WORST_CASE(Omega(n^1),O(n^2)) * Step 1: Sum WORST_CASE(Omega(n^1),O(n^2)) + Considered Problem: - Strict TRS: domatch(patcs,Cons(x,xs),n) -> domatch[Ite](prefix(patcs,Cons(x,xs)),patcs,Cons(x,xs),n) domatch(Cons(x,xs),Nil(),n) -> Nil() domatch(Nil(),Nil(),n) -> Cons(n,Nil()) eqNatList(Cons(x,xs),Cons(y,ys)) -> eqNatList[Ite](!EQ(x,y),y,ys,x,xs) eqNatList(Cons(x,xs),Nil()) -> False() eqNatList(Nil(),Cons(y,ys)) -> False() eqNatList(Nil(),Nil()) -> True() notEmpty(Cons(x,xs)) -> True() notEmpty(Nil()) -> False() prefix(Cons(x,xs),Nil()) -> False() prefix(Cons(x',xs'),Cons(x,xs)) -> and(!EQ(x',x),prefix(xs',xs)) prefix(Nil(),cs) -> True() strmatch(patstr,str) -> domatch(patstr,str,Nil()) - Weak TRS: !EQ(0(),0()) -> True() !EQ(0(),S(y)) -> False() !EQ(S(x),0()) -> False() !EQ(S(x),S(y)) -> !EQ(x,y) and(False(),False()) -> False() and(False(),True()) -> False() and(True(),False()) -> False() and(True(),True()) -> True() domatch[Ite](False(),patcs,Cons(x,xs),n) -> domatch(patcs,xs,Cons(n,Cons(Nil(),Nil()))) domatch[Ite](True(),patcs,Cons(x,xs),n) -> Cons(n,domatch(patcs,xs,Cons(n,Cons(Nil(),Nil())))) eqNatList[Ite](False(),y,ys,x,xs) -> False() eqNatList[Ite](True(),y,ys,x,xs) -> eqNatList(xs,ys) - Signature: {!EQ/2,and/2,domatch/3,domatch[Ite]/4,eqNatList/2,eqNatList[Ite]/5,notEmpty/1,prefix/2,strmatch/2} / {0/0 ,Cons/2,False/0,Nil/0,S/1,True/0} - Obligation: innermost runtime complexity wrt. defined symbols {!EQ,and,domatch,domatch[Ite],eqNatList,eqNatList[Ite] ,notEmpty,prefix,strmatch} and constructors {0,Cons,False,Nil,S,True} + Applied Processor: Sum {left = someStrategy, right = someStrategy} + Details: () ** Step 1.a:1: DecreasingLoops WORST_CASE(Omega(n^1),?) + Considered Problem: - Strict TRS: domatch(patcs,Cons(x,xs),n) -> domatch[Ite](prefix(patcs,Cons(x,xs)),patcs,Cons(x,xs),n) domatch(Cons(x,xs),Nil(),n) -> Nil() domatch(Nil(),Nil(),n) -> Cons(n,Nil()) eqNatList(Cons(x,xs),Cons(y,ys)) -> eqNatList[Ite](!EQ(x,y),y,ys,x,xs) eqNatList(Cons(x,xs),Nil()) -> False() eqNatList(Nil(),Cons(y,ys)) -> False() eqNatList(Nil(),Nil()) -> True() notEmpty(Cons(x,xs)) -> True() notEmpty(Nil()) -> False() prefix(Cons(x,xs),Nil()) -> False() prefix(Cons(x',xs'),Cons(x,xs)) -> and(!EQ(x',x),prefix(xs',xs)) prefix(Nil(),cs) -> True() strmatch(patstr,str) -> domatch(patstr,str,Nil()) - Weak TRS: !EQ(0(),0()) -> True() !EQ(0(),S(y)) -> False() !EQ(S(x),0()) -> False() !EQ(S(x),S(y)) -> !EQ(x,y) and(False(),False()) -> False() and(False(),True()) -> False() and(True(),False()) -> False() and(True(),True()) -> True() domatch[Ite](False(),patcs,Cons(x,xs),n) -> domatch(patcs,xs,Cons(n,Cons(Nil(),Nil()))) domatch[Ite](True(),patcs,Cons(x,xs),n) -> Cons(n,domatch(patcs,xs,Cons(n,Cons(Nil(),Nil())))) eqNatList[Ite](False(),y,ys,x,xs) -> False() eqNatList[Ite](True(),y,ys,x,xs) -> eqNatList(xs,ys) - Signature: {!EQ/2,and/2,domatch/3,domatch[Ite]/4,eqNatList/2,eqNatList[Ite]/5,notEmpty/1,prefix/2,strmatch/2} / {0/0 ,Cons/2,False/0,Nil/0,S/1,True/0} - Obligation: innermost runtime complexity wrt. defined symbols {!EQ,and,domatch,domatch[Ite],eqNatList,eqNatList[Ite] ,notEmpty,prefix,strmatch} and constructors {0,Cons,False,Nil,S,True} + Applied Processor: DecreasingLoops {bound = AnyLoop, narrow = 10} + Details: The system has following decreasing Loops: prefix(y,u){y -> Cons(x,y),u -> Cons(z,u)} = prefix(Cons(x,y),Cons(z,u)) ->^+ and(!EQ(x,z),prefix(y,u)) = C[prefix(y,u) = prefix(y,u){}] ** Step 1.b:1: NaturalMI WORST_CASE(?,O(n^2)) + Considered Problem: - Strict TRS: domatch(patcs,Cons(x,xs),n) -> domatch[Ite](prefix(patcs,Cons(x,xs)),patcs,Cons(x,xs),n) domatch(Cons(x,xs),Nil(),n) -> Nil() domatch(Nil(),Nil(),n) -> Cons(n,Nil()) eqNatList(Cons(x,xs),Cons(y,ys)) -> eqNatList[Ite](!EQ(x,y),y,ys,x,xs) eqNatList(Cons(x,xs),Nil()) -> False() eqNatList(Nil(),Cons(y,ys)) -> False() eqNatList(Nil(),Nil()) -> True() notEmpty(Cons(x,xs)) -> True() notEmpty(Nil()) -> False() prefix(Cons(x,xs),Nil()) -> False() prefix(Cons(x',xs'),Cons(x,xs)) -> and(!EQ(x',x),prefix(xs',xs)) prefix(Nil(),cs) -> True() strmatch(patstr,str) -> domatch(patstr,str,Nil()) - Weak TRS: !EQ(0(),0()) -> True() !EQ(0(),S(y)) -> False() !EQ(S(x),0()) -> False() !EQ(S(x),S(y)) -> !EQ(x,y) and(False(),False()) -> False() and(False(),True()) -> False() and(True(),False()) -> False() and(True(),True()) -> True() domatch[Ite](False(),patcs,Cons(x,xs),n) -> domatch(patcs,xs,Cons(n,Cons(Nil(),Nil()))) domatch[Ite](True(),patcs,Cons(x,xs),n) -> Cons(n,domatch(patcs,xs,Cons(n,Cons(Nil(),Nil())))) eqNatList[Ite](False(),y,ys,x,xs) -> False() eqNatList[Ite](True(),y,ys,x,xs) -> eqNatList(xs,ys) - Signature: {!EQ/2,and/2,domatch/3,domatch[Ite]/4,eqNatList/2,eqNatList[Ite]/5,notEmpty/1,prefix/2,strmatch/2} / {0/0 ,Cons/2,False/0,Nil/0,S/1,True/0} - Obligation: innermost runtime complexity wrt. defined symbols {!EQ,and,domatch,domatch[Ite],eqNatList,eqNatList[Ite] ,notEmpty,prefix,strmatch} and constructors {0,Cons,False,Nil,S,True} + Applied Processor: NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just any strict-rules} + Details: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(Cons) = {2}, uargs(and) = {1,2}, uargs(domatch[Ite]) = {1}, uargs(eqNatList[Ite]) = {1} Following symbols are considered usable: {!EQ,and,domatch,domatch[Ite],eqNatList,eqNatList[Ite],notEmpty,prefix,strmatch} TcT has computed the following interpretation: p(!EQ) = [0] p(0) = [4] p(Cons) = [1] x2 + [0] p(False) = [0] p(Nil) = [0] p(S) = [1] p(True) = [0] p(and) = [4] x1 + [4] x2 + [0] p(domatch) = [0] p(domatch[Ite]) = [4] x1 + [0] p(eqNatList) = [2] p(eqNatList[Ite]) = [2] x1 + [2] p(notEmpty) = [3] p(prefix) = [0] p(strmatch) = [0] Following rules are strictly oriented: eqNatList(Cons(x,xs),Nil()) = [2] > [0] = False() eqNatList(Nil(),Cons(y,ys)) = [2] > [0] = False() eqNatList(Nil(),Nil()) = [2] > [0] = True() notEmpty(Cons(x,xs)) = [3] > [0] = True() notEmpty(Nil()) = [3] > [0] = False() Following rules are (at-least) weakly oriented: !EQ(0(),0()) = [0] >= [0] = True() !EQ(0(),S(y)) = [0] >= [0] = False() !EQ(S(x),0()) = [0] >= [0] = False() !EQ(S(x),S(y)) = [0] >= [0] = !EQ(x,y) and(False(),False()) = [0] >= [0] = False() and(False(),True()) = [0] >= [0] = False() and(True(),False()) = [0] >= [0] = False() and(True(),True()) = [0] >= [0] = True() domatch(patcs,Cons(x,xs),n) = [0] >= [0] = domatch[Ite](prefix(patcs,Cons(x,xs)),patcs,Cons(x,xs),n) domatch(Cons(x,xs),Nil(),n) = [0] >= [0] = Nil() domatch(Nil(),Nil(),n) = [0] >= [0] = Cons(n,Nil()) domatch[Ite](False(),patcs,Cons(x,xs),n) = [0] >= [0] = domatch(patcs,xs,Cons(n,Cons(Nil(),Nil()))) domatch[Ite](True(),patcs,Cons(x,xs),n) = [0] >= [0] = Cons(n,domatch(patcs,xs,Cons(n,Cons(Nil(),Nil())))) eqNatList(Cons(x,xs),Cons(y,ys)) = [2] >= [2] = eqNatList[Ite](!EQ(x,y),y,ys,x,xs) eqNatList[Ite](False(),y,ys,x,xs) = [2] >= [0] = False() eqNatList[Ite](True(),y,ys,x,xs) = [2] >= [2] = eqNatList(xs,ys) prefix(Cons(x,xs),Nil()) = [0] >= [0] = False() prefix(Cons(x',xs'),Cons(x,xs)) = [0] >= [0] = and(!EQ(x',x),prefix(xs',xs)) prefix(Nil(),cs) = [0] >= [0] = True() strmatch(patstr,str) = [0] >= [0] = domatch(patstr,str,Nil()) ** Step 1.b:2: NaturalMI WORST_CASE(?,O(n^2)) + Considered Problem: - Strict TRS: domatch(patcs,Cons(x,xs),n) -> domatch[Ite](prefix(patcs,Cons(x,xs)),patcs,Cons(x,xs),n) domatch(Cons(x,xs),Nil(),n) -> Nil() domatch(Nil(),Nil(),n) -> Cons(n,Nil()) eqNatList(Cons(x,xs),Cons(y,ys)) -> eqNatList[Ite](!EQ(x,y),y,ys,x,xs) prefix(Cons(x,xs),Nil()) -> False() prefix(Cons(x',xs'),Cons(x,xs)) -> and(!EQ(x',x),prefix(xs',xs)) prefix(Nil(),cs) -> True() strmatch(patstr,str) -> domatch(patstr,str,Nil()) - Weak TRS: !EQ(0(),0()) -> True() !EQ(0(),S(y)) -> False() !EQ(S(x),0()) -> False() !EQ(S(x),S(y)) -> !EQ(x,y) and(False(),False()) -> False() and(False(),True()) -> False() and(True(),False()) -> False() and(True(),True()) -> True() domatch[Ite](False(),patcs,Cons(x,xs),n) -> domatch(patcs,xs,Cons(n,Cons(Nil(),Nil()))) domatch[Ite](True(),patcs,Cons(x,xs),n) -> Cons(n,domatch(patcs,xs,Cons(n,Cons(Nil(),Nil())))) eqNatList(Cons(x,xs),Nil()) -> False() eqNatList(Nil(),Cons(y,ys)) -> False() eqNatList(Nil(),Nil()) -> True() eqNatList[Ite](False(),y,ys,x,xs) -> False() eqNatList[Ite](True(),y,ys,x,xs) -> eqNatList(xs,ys) notEmpty(Cons(x,xs)) -> True() notEmpty(Nil()) -> False() - Signature: {!EQ/2,and/2,domatch/3,domatch[Ite]/4,eqNatList/2,eqNatList[Ite]/5,notEmpty/1,prefix/2,strmatch/2} / {0/0 ,Cons/2,False/0,Nil/0,S/1,True/0} - Obligation: innermost runtime complexity wrt. defined symbols {!EQ,and,domatch,domatch[Ite],eqNatList,eqNatList[Ite] ,notEmpty,prefix,strmatch} and constructors {0,Cons,False,Nil,S,True} + Applied Processor: NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just any strict-rules} + Details: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(Cons) = {2}, uargs(and) = {1,2}, uargs(domatch[Ite]) = {1}, uargs(eqNatList[Ite]) = {1} Following symbols are considered usable: {!EQ,and,domatch,domatch[Ite],eqNatList,eqNatList[Ite],notEmpty,prefix,strmatch} TcT has computed the following interpretation: p(!EQ) = [0] p(0) = [0] p(Cons) = [1] x2 + [2] p(False) = [0] p(Nil) = [0] p(S) = [0] p(True) = [0] p(and) = [4] x1 + [2] x2 + [0] p(domatch) = [4] x2 + [1] x3 + [4] p(domatch[Ite]) = [2] x1 + [4] x3 + [2] p(eqNatList) = [3] p(eqNatList[Ite]) = [2] x1 + [3] p(notEmpty) = [2] p(prefix) = [0] p(strmatch) = [4] x2 + [4] Following rules are strictly oriented: domatch(patcs,Cons(x,xs),n) = [1] n + [4] xs + [12] > [4] xs + [10] = domatch[Ite](prefix(patcs,Cons(x,xs)),patcs,Cons(x,xs),n) domatch(Cons(x,xs),Nil(),n) = [1] n + [4] > [0] = Nil() domatch(Nil(),Nil(),n) = [1] n + [4] > [2] = Cons(n,Nil()) Following rules are (at-least) weakly oriented: !EQ(0(),0()) = [0] >= [0] = True() !EQ(0(),S(y)) = [0] >= [0] = False() !EQ(S(x),0()) = [0] >= [0] = False() !EQ(S(x),S(y)) = [0] >= [0] = !EQ(x,y) and(False(),False()) = [0] >= [0] = False() and(False(),True()) = [0] >= [0] = False() and(True(),False()) = [0] >= [0] = False() and(True(),True()) = [0] >= [0] = True() domatch[Ite](False(),patcs,Cons(x,xs),n) = [4] xs + [10] >= [4] xs + [8] = domatch(patcs,xs,Cons(n,Cons(Nil(),Nil()))) domatch[Ite](True(),patcs,Cons(x,xs),n) = [4] xs + [10] >= [4] xs + [10] = Cons(n,domatch(patcs,xs,Cons(n,Cons(Nil(),Nil())))) eqNatList(Cons(x,xs),Cons(y,ys)) = [3] >= [3] = eqNatList[Ite](!EQ(x,y),y,ys,x,xs) eqNatList(Cons(x,xs),Nil()) = [3] >= [0] = False() eqNatList(Nil(),Cons(y,ys)) = [3] >= [0] = False() eqNatList(Nil(),Nil()) = [3] >= [0] = True() eqNatList[Ite](False(),y,ys,x,xs) = [3] >= [0] = False() eqNatList[Ite](True(),y,ys,x,xs) = [3] >= [3] = eqNatList(xs,ys) notEmpty(Cons(x,xs)) = [2] >= [0] = True() notEmpty(Nil()) = [2] >= [0] = False() prefix(Cons(x,xs),Nil()) = [0] >= [0] = False() prefix(Cons(x',xs'),Cons(x,xs)) = [0] >= [0] = and(!EQ(x',x),prefix(xs',xs)) prefix(Nil(),cs) = [0] >= [0] = True() strmatch(patstr,str) = [4] str + [4] >= [4] str + [4] = domatch(patstr,str,Nil()) ** Step 1.b:3: NaturalMI WORST_CASE(?,O(n^2)) + Considered Problem: - Strict TRS: eqNatList(Cons(x,xs),Cons(y,ys)) -> eqNatList[Ite](!EQ(x,y),y,ys,x,xs) prefix(Cons(x,xs),Nil()) -> False() prefix(Cons(x',xs'),Cons(x,xs)) -> and(!EQ(x',x),prefix(xs',xs)) prefix(Nil(),cs) -> True() strmatch(patstr,str) -> domatch(patstr,str,Nil()) - Weak TRS: !EQ(0(),0()) -> True() !EQ(0(),S(y)) -> False() !EQ(S(x),0()) -> False() !EQ(S(x),S(y)) -> !EQ(x,y) and(False(),False()) -> False() and(False(),True()) -> False() and(True(),False()) -> False() and(True(),True()) -> True() domatch(patcs,Cons(x,xs),n) -> domatch[Ite](prefix(patcs,Cons(x,xs)),patcs,Cons(x,xs),n) domatch(Cons(x,xs),Nil(),n) -> Nil() domatch(Nil(),Nil(),n) -> Cons(n,Nil()) domatch[Ite](False(),patcs,Cons(x,xs),n) -> domatch(patcs,xs,Cons(n,Cons(Nil(),Nil()))) domatch[Ite](True(),patcs,Cons(x,xs),n) -> Cons(n,domatch(patcs,xs,Cons(n,Cons(Nil(),Nil())))) eqNatList(Cons(x,xs),Nil()) -> False() eqNatList(Nil(),Cons(y,ys)) -> False() eqNatList(Nil(),Nil()) -> True() eqNatList[Ite](False(),y,ys,x,xs) -> False() eqNatList[Ite](True(),y,ys,x,xs) -> eqNatList(xs,ys) notEmpty(Cons(x,xs)) -> True() notEmpty(Nil()) -> False() - Signature: {!EQ/2,and/2,domatch/3,domatch[Ite]/4,eqNatList/2,eqNatList[Ite]/5,notEmpty/1,prefix/2,strmatch/2} / {0/0 ,Cons/2,False/0,Nil/0,S/1,True/0} - Obligation: innermost runtime complexity wrt. defined symbols {!EQ,and,domatch,domatch[Ite],eqNatList,eqNatList[Ite] ,notEmpty,prefix,strmatch} and constructors {0,Cons,False,Nil,S,True} + Applied Processor: NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just any strict-rules} + Details: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(Cons) = {2}, uargs(and) = {1,2}, uargs(domatch[Ite]) = {1}, uargs(eqNatList[Ite]) = {1} Following symbols are considered usable: {!EQ,and,domatch,domatch[Ite],eqNatList,eqNatList[Ite],notEmpty,prefix,strmatch} TcT has computed the following interpretation: p(!EQ) = [0] p(0) = [0] p(Cons) = [1] x2 + [0] p(False) = [0] p(Nil) = [0] p(S) = [1] x1 + [1] p(True) = [0] p(and) = [2] x1 + [4] x2 + [0] p(domatch) = [2] x3 + [0] p(domatch[Ite]) = [1] x1 + [0] p(eqNatList) = [7] p(eqNatList[Ite]) = [1] x1 + [7] p(notEmpty) = [4] p(prefix) = [0] p(strmatch) = [1] x1 + [1] x2 + [4] Following rules are strictly oriented: strmatch(patstr,str) = [1] patstr + [1] str + [4] > [0] = domatch(patstr,str,Nil()) Following rules are (at-least) weakly oriented: !EQ(0(),0()) = [0] >= [0] = True() !EQ(0(),S(y)) = [0] >= [0] = False() !EQ(S(x),0()) = [0] >= [0] = False() !EQ(S(x),S(y)) = [0] >= [0] = !EQ(x,y) and(False(),False()) = [0] >= [0] = False() and(False(),True()) = [0] >= [0] = False() and(True(),False()) = [0] >= [0] = False() and(True(),True()) = [0] >= [0] = True() domatch(patcs,Cons(x,xs),n) = [2] n + [0] >= [0] = domatch[Ite](prefix(patcs,Cons(x,xs)),patcs,Cons(x,xs),n) domatch(Cons(x,xs),Nil(),n) = [2] n + [0] >= [0] = Nil() domatch(Nil(),Nil(),n) = [2] n + [0] >= [0] = Cons(n,Nil()) domatch[Ite](False(),patcs,Cons(x,xs),n) = [0] >= [0] = domatch(patcs,xs,Cons(n,Cons(Nil(),Nil()))) domatch[Ite](True(),patcs,Cons(x,xs),n) = [0] >= [0] = Cons(n,domatch(patcs,xs,Cons(n,Cons(Nil(),Nil())))) eqNatList(Cons(x,xs),Cons(y,ys)) = [7] >= [7] = eqNatList[Ite](!EQ(x,y),y,ys,x,xs) eqNatList(Cons(x,xs),Nil()) = [7] >= [0] = False() eqNatList(Nil(),Cons(y,ys)) = [7] >= [0] = False() eqNatList(Nil(),Nil()) = [7] >= [0] = True() eqNatList[Ite](False(),y,ys,x,xs) = [7] >= [0] = False() eqNatList[Ite](True(),y,ys,x,xs) = [7] >= [7] = eqNatList(xs,ys) notEmpty(Cons(x,xs)) = [4] >= [0] = True() notEmpty(Nil()) = [4] >= [0] = False() prefix(Cons(x,xs),Nil()) = [0] >= [0] = False() prefix(Cons(x',xs'),Cons(x,xs)) = [0] >= [0] = and(!EQ(x',x),prefix(xs',xs)) prefix(Nil(),cs) = [0] >= [0] = True() ** Step 1.b:4: NaturalMI WORST_CASE(?,O(n^2)) + Considered Problem: - Strict TRS: eqNatList(Cons(x,xs),Cons(y,ys)) -> eqNatList[Ite](!EQ(x,y),y,ys,x,xs) prefix(Cons(x,xs),Nil()) -> False() prefix(Cons(x',xs'),Cons(x,xs)) -> and(!EQ(x',x),prefix(xs',xs)) prefix(Nil(),cs) -> True() - Weak TRS: !EQ(0(),0()) -> True() !EQ(0(),S(y)) -> False() !EQ(S(x),0()) -> False() !EQ(S(x),S(y)) -> !EQ(x,y) and(False(),False()) -> False() and(False(),True()) -> False() and(True(),False()) -> False() and(True(),True()) -> True() domatch(patcs,Cons(x,xs),n) -> domatch[Ite](prefix(patcs,Cons(x,xs)),patcs,Cons(x,xs),n) domatch(Cons(x,xs),Nil(),n) -> Nil() domatch(Nil(),Nil(),n) -> Cons(n,Nil()) domatch[Ite](False(),patcs,Cons(x,xs),n) -> domatch(patcs,xs,Cons(n,Cons(Nil(),Nil()))) domatch[Ite](True(),patcs,Cons(x,xs),n) -> Cons(n,domatch(patcs,xs,Cons(n,Cons(Nil(),Nil())))) eqNatList(Cons(x,xs),Nil()) -> False() eqNatList(Nil(),Cons(y,ys)) -> False() eqNatList(Nil(),Nil()) -> True() eqNatList[Ite](False(),y,ys,x,xs) -> False() eqNatList[Ite](True(),y,ys,x,xs) -> eqNatList(xs,ys) notEmpty(Cons(x,xs)) -> True() notEmpty(Nil()) -> False() strmatch(patstr,str) -> domatch(patstr,str,Nil()) - Signature: {!EQ/2,and/2,domatch/3,domatch[Ite]/4,eqNatList/2,eqNatList[Ite]/5,notEmpty/1,prefix/2,strmatch/2} / {0/0 ,Cons/2,False/0,Nil/0,S/1,True/0} - Obligation: innermost runtime complexity wrt. defined symbols {!EQ,and,domatch,domatch[Ite],eqNatList,eqNatList[Ite] ,notEmpty,prefix,strmatch} and constructors {0,Cons,False,Nil,S,True} + Applied Processor: NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just any strict-rules} + Details: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(Cons) = {2}, uargs(and) = {1,2}, uargs(domatch[Ite]) = {1}, uargs(eqNatList[Ite]) = {1} Following symbols are considered usable: {!EQ,and,domatch,domatch[Ite],eqNatList,eqNatList[Ite],notEmpty,prefix,strmatch} TcT has computed the following interpretation: p(!EQ) = [0] p(0) = [0] p(Cons) = [1] x2 + [2] p(False) = [0] p(Nil) = [4] p(S) = [0] p(True) = [0] p(and) = [4] x1 + [4] x2 + [0] p(domatch) = [1] x1 + [1] x2 + [0] p(domatch[Ite]) = [2] x1 + [1] x2 + [1] x3 + [0] p(eqNatList) = [2] x2 + [2] p(eqNatList[Ite]) = [4] x1 + [2] x3 + [4] p(notEmpty) = [2] x1 + [5] p(prefix) = [0] p(strmatch) = [1] x1 + [1] x2 + [5] Following rules are strictly oriented: eqNatList(Cons(x,xs),Cons(y,ys)) = [2] ys + [6] > [2] ys + [4] = eqNatList[Ite](!EQ(x,y),y,ys,x,xs) Following rules are (at-least) weakly oriented: !EQ(0(),0()) = [0] >= [0] = True() !EQ(0(),S(y)) = [0] >= [0] = False() !EQ(S(x),0()) = [0] >= [0] = False() !EQ(S(x),S(y)) = [0] >= [0] = !EQ(x,y) and(False(),False()) = [0] >= [0] = False() and(False(),True()) = [0] >= [0] = False() and(True(),False()) = [0] >= [0] = False() and(True(),True()) = [0] >= [0] = True() domatch(patcs,Cons(x,xs),n) = [1] patcs + [1] xs + [2] >= [1] patcs + [1] xs + [2] = domatch[Ite](prefix(patcs,Cons(x,xs)),patcs,Cons(x,xs),n) domatch(Cons(x,xs),Nil(),n) = [1] xs + [6] >= [4] = Nil() domatch(Nil(),Nil(),n) = [8] >= [6] = Cons(n,Nil()) domatch[Ite](False(),patcs,Cons(x,xs),n) = [1] patcs + [1] xs + [2] >= [1] patcs + [1] xs + [0] = domatch(patcs,xs,Cons(n,Cons(Nil(),Nil()))) domatch[Ite](True(),patcs,Cons(x,xs),n) = [1] patcs + [1] xs + [2] >= [1] patcs + [1] xs + [2] = Cons(n,domatch(patcs,xs,Cons(n,Cons(Nil(),Nil())))) eqNatList(Cons(x,xs),Nil()) = [10] >= [0] = False() eqNatList(Nil(),Cons(y,ys)) = [2] ys + [6] >= [0] = False() eqNatList(Nil(),Nil()) = [10] >= [0] = True() eqNatList[Ite](False(),y,ys,x,xs) = [2] ys + [4] >= [0] = False() eqNatList[Ite](True(),y,ys,x,xs) = [2] ys + [4] >= [2] ys + [2] = eqNatList(xs,ys) notEmpty(Cons(x,xs)) = [2] xs + [9] >= [0] = True() notEmpty(Nil()) = [13] >= [0] = False() prefix(Cons(x,xs),Nil()) = [0] >= [0] = False() prefix(Cons(x',xs'),Cons(x,xs)) = [0] >= [0] = and(!EQ(x',x),prefix(xs',xs)) prefix(Nil(),cs) = [0] >= [0] = True() strmatch(patstr,str) = [1] patstr + [1] str + [5] >= [1] patstr + [1] str + [0] = domatch(patstr,str,Nil()) ** Step 1.b:5: NaturalMI WORST_CASE(?,O(n^2)) + Considered Problem: - Strict TRS: prefix(Cons(x,xs),Nil()) -> False() prefix(Cons(x',xs'),Cons(x,xs)) -> and(!EQ(x',x),prefix(xs',xs)) prefix(Nil(),cs) -> True() - Weak TRS: !EQ(0(),0()) -> True() !EQ(0(),S(y)) -> False() !EQ(S(x),0()) -> False() !EQ(S(x),S(y)) -> !EQ(x,y) and(False(),False()) -> False() and(False(),True()) -> False() and(True(),False()) -> False() and(True(),True()) -> True() domatch(patcs,Cons(x,xs),n) -> domatch[Ite](prefix(patcs,Cons(x,xs)),patcs,Cons(x,xs),n) domatch(Cons(x,xs),Nil(),n) -> Nil() domatch(Nil(),Nil(),n) -> Cons(n,Nil()) domatch[Ite](False(),patcs,Cons(x,xs),n) -> domatch(patcs,xs,Cons(n,Cons(Nil(),Nil()))) domatch[Ite](True(),patcs,Cons(x,xs),n) -> Cons(n,domatch(patcs,xs,Cons(n,Cons(Nil(),Nil())))) eqNatList(Cons(x,xs),Cons(y,ys)) -> eqNatList[Ite](!EQ(x,y),y,ys,x,xs) eqNatList(Cons(x,xs),Nil()) -> False() eqNatList(Nil(),Cons(y,ys)) -> False() eqNatList(Nil(),Nil()) -> True() eqNatList[Ite](False(),y,ys,x,xs) -> False() eqNatList[Ite](True(),y,ys,x,xs) -> eqNatList(xs,ys) notEmpty(Cons(x,xs)) -> True() notEmpty(Nil()) -> False() strmatch(patstr,str) -> domatch(patstr,str,Nil()) - Signature: {!EQ/2,and/2,domatch/3,domatch[Ite]/4,eqNatList/2,eqNatList[Ite]/5,notEmpty/1,prefix/2,strmatch/2} / {0/0 ,Cons/2,False/0,Nil/0,S/1,True/0} - Obligation: innermost runtime complexity wrt. defined symbols {!EQ,and,domatch,domatch[Ite],eqNatList,eqNatList[Ite] ,notEmpty,prefix,strmatch} and constructors {0,Cons,False,Nil,S,True} + Applied Processor: NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just any strict-rules} + Details: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(Cons) = {2}, uargs(and) = {1,2}, uargs(domatch[Ite]) = {1}, uargs(eqNatList[Ite]) = {1} Following symbols are considered usable: {!EQ,and,domatch,domatch[Ite],eqNatList,eqNatList[Ite],notEmpty,prefix,strmatch} TcT has computed the following interpretation: p(!EQ) = [0] p(0) = [0] p(Cons) = [1] x2 + [2] p(False) = [0] p(Nil) = [0] p(S) = [1] p(True) = [0] p(and) = [4] x1 + [1] x2 + [0] p(domatch) = [2] x2 + [4] p(domatch[Ite]) = [2] x1 + [2] x3 + [2] p(eqNatList) = [4] p(eqNatList[Ite]) = [2] x1 + [4] p(notEmpty) = [4] p(prefix) = [1] p(strmatch) = [1] x1 + [3] x2 + [4] Following rules are strictly oriented: prefix(Cons(x,xs),Nil()) = [1] > [0] = False() prefix(Nil(),cs) = [1] > [0] = True() Following rules are (at-least) weakly oriented: !EQ(0(),0()) = [0] >= [0] = True() !EQ(0(),S(y)) = [0] >= [0] = False() !EQ(S(x),0()) = [0] >= [0] = False() !EQ(S(x),S(y)) = [0] >= [0] = !EQ(x,y) and(False(),False()) = [0] >= [0] = False() and(False(),True()) = [0] >= [0] = False() and(True(),False()) = [0] >= [0] = False() and(True(),True()) = [0] >= [0] = True() domatch(patcs,Cons(x,xs),n) = [2] xs + [8] >= [2] xs + [8] = domatch[Ite](prefix(patcs,Cons(x,xs)),patcs,Cons(x,xs),n) domatch(Cons(x,xs),Nil(),n) = [4] >= [0] = Nil() domatch(Nil(),Nil(),n) = [4] >= [2] = Cons(n,Nil()) domatch[Ite](False(),patcs,Cons(x,xs),n) = [2] xs + [6] >= [2] xs + [4] = domatch(patcs,xs,Cons(n,Cons(Nil(),Nil()))) domatch[Ite](True(),patcs,Cons(x,xs),n) = [2] xs + [6] >= [2] xs + [6] = Cons(n,domatch(patcs,xs,Cons(n,Cons(Nil(),Nil())))) eqNatList(Cons(x,xs),Cons(y,ys)) = [4] >= [4] = eqNatList[Ite](!EQ(x,y),y,ys,x,xs) eqNatList(Cons(x,xs),Nil()) = [4] >= [0] = False() eqNatList(Nil(),Cons(y,ys)) = [4] >= [0] = False() eqNatList(Nil(),Nil()) = [4] >= [0] = True() eqNatList[Ite](False(),y,ys,x,xs) = [4] >= [0] = False() eqNatList[Ite](True(),y,ys,x,xs) = [4] >= [4] = eqNatList(xs,ys) notEmpty(Cons(x,xs)) = [4] >= [0] = True() notEmpty(Nil()) = [4] >= [0] = False() prefix(Cons(x',xs'),Cons(x,xs)) = [1] >= [1] = and(!EQ(x',x),prefix(xs',xs)) strmatch(patstr,str) = [1] patstr + [3] str + [4] >= [2] str + [4] = domatch(patstr,str,Nil()) ** Step 1.b:6: Ara WORST_CASE(?,O(n^2)) + Considered Problem: - Strict TRS: prefix(Cons(x',xs'),Cons(x,xs)) -> and(!EQ(x',x),prefix(xs',xs)) - Weak TRS: !EQ(0(),0()) -> True() !EQ(0(),S(y)) -> False() !EQ(S(x),0()) -> False() !EQ(S(x),S(y)) -> !EQ(x,y) and(False(),False()) -> False() and(False(),True()) -> False() and(True(),False()) -> False() and(True(),True()) -> True() domatch(patcs,Cons(x,xs),n) -> domatch[Ite](prefix(patcs,Cons(x,xs)),patcs,Cons(x,xs),n) domatch(Cons(x,xs),Nil(),n) -> Nil() domatch(Nil(),Nil(),n) -> Cons(n,Nil()) domatch[Ite](False(),patcs,Cons(x,xs),n) -> domatch(patcs,xs,Cons(n,Cons(Nil(),Nil()))) domatch[Ite](True(),patcs,Cons(x,xs),n) -> Cons(n,domatch(patcs,xs,Cons(n,Cons(Nil(),Nil())))) eqNatList(Cons(x,xs),Cons(y,ys)) -> eqNatList[Ite](!EQ(x,y),y,ys,x,xs) eqNatList(Cons(x,xs),Nil()) -> False() eqNatList(Nil(),Cons(y,ys)) -> False() eqNatList(Nil(),Nil()) -> True() eqNatList[Ite](False(),y,ys,x,xs) -> False() eqNatList[Ite](True(),y,ys,x,xs) -> eqNatList(xs,ys) notEmpty(Cons(x,xs)) -> True() notEmpty(Nil()) -> False() prefix(Cons(x,xs),Nil()) -> False() prefix(Nil(),cs) -> True() strmatch(patstr,str) -> domatch(patstr,str,Nil()) - Signature: {!EQ/2,and/2,domatch/3,domatch[Ite]/4,eqNatList/2,eqNatList[Ite]/5,notEmpty/1,prefix/2,strmatch/2} / {0/0 ,Cons/2,False/0,Nil/0,S/1,True/0} - Obligation: innermost runtime complexity wrt. defined symbols {!EQ,and,domatch,domatch[Ite],eqNatList,eqNatList[Ite] ,notEmpty,prefix,strmatch} and constructors {0,Cons,False,Nil,S,True} + Applied Processor: Ara {araHeuristics = NoHeuristics, minDegree = 2, maxDegree = 2, araTimeout = 8, araRuleShifting = Just 1} + Details: Signatures used: ---------------- !EQ :: ["A"(0, 0) x "A"(0, 0)] -(0)-> "A"(0, 0) 0 :: [] -(0)-> "A"(0, 0) Cons :: ["A"(0, 0) x "A"(0, 0)] -(0)-> "A"(0, 0) Cons :: ["A"(0, 0) x "A"(1, 0)] -(1)-> "A"(1, 0) Cons :: ["A"(1, 1) x "A"(6, 1)] -(5)-> "A"(5, 1) Cons :: ["A"(0, 0) x "A"(10, 0)] -(10)-> "A"(10, 0) Cons :: ["A"(1, 1) x "A"(5, 1)] -(4)-> "A"(4, 1) Cons :: ["A"(8, 8) x "A"(14, 8)] -(6)-> "A"(6, 8) Cons :: ["A"(4, 4) x "A"(12, 4)] -(8)-> "A"(8, 4) Cons :: ["A"(9, 9) x "A"(13, 9)] -(4)-> "A"(4, 9) Cons :: ["A"(0, 0) x "A"(2, 0)] -(2)-> "A"(2, 0) Cons :: ["A"(12, 12) x "A"(12, 12)] -(0)-> "A"(0, 12) False :: [] -(0)-> "A"(0, 0) Nil :: [] -(0)-> "A"(5, 1) Nil :: [] -(0)-> "A"(10, 0) Nil :: [] -(0)-> "A"(8, 4) Nil :: [] -(0)-> "A"(6, 8) Nil :: [] -(0)-> "A"(4, 9) Nil :: [] -(0)-> "A"(1, 0) Nil :: [] -(0)-> "A"(0, 0) Nil :: [] -(0)-> "A"(0, 15) Nil :: [] -(0)-> "A"(7, 9) Nil :: [] -(0)-> "A"(12, 12) Nil :: [] -(0)-> "A"(14, 15) Nil :: [] -(0)-> "A"(8, 9) Nil :: [] -(0)-> "A"(15, 9) Nil :: [] -(0)-> "A"(8, 0) S :: ["A"(0, 0)] -(0)-> "A"(0, 0) True :: [] -(0)-> "A"(0, 0) and :: ["A"(0, 0) x "A"(0, 0)] -(0)-> "A"(0, 0) domatch :: ["A"(10, 0) x "A"(5, 1) x "A"(0, 0)] -(7)-> "A"(0, 0) domatch[Ite] :: ["A"(0, 0) x "A"(10, 0) x "A"(4, 1) x "A"(0, 0)] -(7)-> "A"(0, 0) eqNatList :: ["A"(6, 8) x "A"(8, 4)] -(8)-> "A"(0, 0) eqNatList[Ite] :: ["A"(0, 0) x "A"(0, 0) x "A"(8, 4) x "A"(0, 0) x "A"(6, 8)] -(8)-> "A"(0, 0) notEmpty :: ["A"(4, 9)] -(0)-> "A"(0, 0) prefix :: ["A"(0, 0) x "A"(1, 0)] -(0)-> "A"(0, 0) strmatch :: ["A"(14, 14) x "A"(15, 15)] -(14)-> "A"(0, 0) Cost-free Signatures used: -------------------------- Base Constructor Signatures used: --------------------------------- "0_A" :: [] -(1)-> "A"(1, 0) "0_A" :: [] -(1)-> "A"(0, 1) "Cons_A" :: ["A"(0, 0) x "A"(1, 0)] -(1)-> "A"(1, 0) "Cons_A" :: ["A"(1, 1) x "A"(1, 1)] -(0)-> "A"(0, 1) "False_A" :: [] -(1)-> "A"(1, 0) "False_A" :: [] -(1)-> "A"(0, 1) "Nil_A" :: [] -(0)-> "A"(1, 0) "Nil_A" :: [] -(0)-> "A"(0, 1) "S_A" :: ["A"(1, 0)] -(0)-> "A"(1, 0) "S_A" :: ["A"(0, 1)] -(1)-> "A"(0, 1) "True_A" :: [] -(1)-> "A"(1, 0) "True_A" :: [] -(1)-> "A"(0, 1) Following Still Strict Rules were Typed as: ------------------------------------------- 1. Strict: prefix(Cons(x',xs'),Cons(x,xs)) -> and(!EQ(x',x),prefix(xs',xs)) 2. Weak: WORST_CASE(Omega(n^1),O(n^2))