MAYBE * Step 1: WeightGap MAYBE + Considered Problem: - Strict TRS: a__dbl(X) -> dbl(X) a__dbl(0()) -> 0() a__dbl(s(X)) -> s(s(dbl(X))) a__dbls(X) -> dbls(X) a__dbls(cons(X,Y)) -> cons(dbl(X),dbls(Y)) a__dbls(nil()) -> nil() a__from(X) -> cons(X,from(s(X))) a__from(X) -> from(X) a__indx(X1,X2) -> indx(X1,X2) a__indx(cons(X,Y),Z) -> cons(sel(X,Z),indx(Y,Z)) a__indx(nil(),X) -> nil() a__sel(X1,X2) -> sel(X1,X2) a__sel(0(),cons(X,Y)) -> mark(X) a__sel(s(X),cons(Y,Z)) -> a__sel(mark(X),mark(Z)) mark(0()) -> 0() mark(cons(X1,X2)) -> cons(X1,X2) mark(dbl(X)) -> a__dbl(mark(X)) mark(dbls(X)) -> a__dbls(mark(X)) mark(from(X)) -> a__from(X) mark(indx(X1,X2)) -> a__indx(mark(X1),X2) mark(nil()) -> nil() mark(s(X)) -> s(X) mark(sel(X1,X2)) -> a__sel(mark(X1),mark(X2)) - Signature: {a__dbl/1,a__dbls/1,a__from/1,a__indx/2,a__sel/2,mark/1} / {0/0,cons/2,dbl/1,dbls/1,from/1,indx/2,nil/0,s/1 ,sel/2} - Obligation: innermost runtime complexity wrt. defined symbols {a__dbl,a__dbls,a__from,a__indx,a__sel ,mark} and constructors {0,cons,dbl,dbls,from,indx,nil,s,sel} + Applied Processor: WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny} + Details: The weightgap principle applies using the following nonconstant growth matrix-interpretation: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(a__dbl) = {1}, uargs(a__dbls) = {1}, uargs(a__indx) = {1}, uargs(a__sel) = {1,2} Following symbols are considered usable: all TcT has computed the following interpretation: p(0) = [0] p(a__dbl) = [1] x1 + [5] p(a__dbls) = [1] x1 + [5] p(a__from) = [0] p(a__indx) = [1] x1 + [0] p(a__sel) = [1] x1 + [1] x2 + [0] p(cons) = [0] p(dbl) = [1] x1 + [0] p(dbls) = [0] p(from) = [0] p(indx) = [0] p(mark) = [3] p(nil) = [0] p(s) = [0] p(sel) = [1] x1 + [1] x2 + [0] Following rules are strictly oriented: a__dbl(X) = [1] X + [5] > [1] X + [0] = dbl(X) a__dbl(0()) = [5] > [0] = 0() a__dbl(s(X)) = [5] > [0] = s(s(dbl(X))) a__dbls(X) = [1] X + [5] > [0] = dbls(X) a__dbls(cons(X,Y)) = [5] > [0] = cons(dbl(X),dbls(Y)) a__dbls(nil()) = [5] > [0] = nil() mark(0()) = [3] > [0] = 0() mark(cons(X1,X2)) = [3] > [0] = cons(X1,X2) mark(from(X)) = [3] > [0] = a__from(X) mark(nil()) = [3] > [0] = nil() mark(s(X)) = [3] > [0] = s(X) Following rules are (at-least) weakly oriented: a__from(X) = [0] >= [0] = cons(X,from(s(X))) a__from(X) = [0] >= [0] = from(X) a__indx(X1,X2) = [1] X1 + [0] >= [0] = indx(X1,X2) a__indx(cons(X,Y),Z) = [0] >= [0] = cons(sel(X,Z),indx(Y,Z)) a__indx(nil(),X) = [0] >= [0] = nil() a__sel(X1,X2) = [1] X1 + [1] X2 + [0] >= [1] X1 + [1] X2 + [0] = sel(X1,X2) a__sel(0(),cons(X,Y)) = [0] >= [3] = mark(X) a__sel(s(X),cons(Y,Z)) = [0] >= [6] = a__sel(mark(X),mark(Z)) mark(dbl(X)) = [3] >= [8] = a__dbl(mark(X)) mark(dbls(X)) = [3] >= [8] = a__dbls(mark(X)) mark(indx(X1,X2)) = [3] >= [3] = a__indx(mark(X1),X2) mark(sel(X1,X2)) = [3] >= [6] = a__sel(mark(X1),mark(X2)) Further, it can be verified that all rules not oriented are covered by the weightgap condition. * Step 2: WeightGap MAYBE + Considered Problem: - Strict TRS: a__from(X) -> cons(X,from(s(X))) a__from(X) -> from(X) a__indx(X1,X2) -> indx(X1,X2) a__indx(cons(X,Y),Z) -> cons(sel(X,Z),indx(Y,Z)) a__indx(nil(),X) -> nil() a__sel(X1,X2) -> sel(X1,X2) a__sel(0(),cons(X,Y)) -> mark(X) a__sel(s(X),cons(Y,Z)) -> a__sel(mark(X),mark(Z)) mark(dbl(X)) -> a__dbl(mark(X)) mark(dbls(X)) -> a__dbls(mark(X)) mark(indx(X1,X2)) -> a__indx(mark(X1),X2) mark(sel(X1,X2)) -> a__sel(mark(X1),mark(X2)) - Weak TRS: a__dbl(X) -> dbl(X) a__dbl(0()) -> 0() a__dbl(s(X)) -> s(s(dbl(X))) a__dbls(X) -> dbls(X) a__dbls(cons(X,Y)) -> cons(dbl(X),dbls(Y)) a__dbls(nil()) -> nil() mark(0()) -> 0() mark(cons(X1,X2)) -> cons(X1,X2) mark(from(X)) -> a__from(X) mark(nil()) -> nil() mark(s(X)) -> s(X) - Signature: {a__dbl/1,a__dbls/1,a__from/1,a__indx/2,a__sel/2,mark/1} / {0/0,cons/2,dbl/1,dbls/1,from/1,indx/2,nil/0,s/1 ,sel/2} - Obligation: innermost runtime complexity wrt. defined symbols {a__dbl,a__dbls,a__from,a__indx,a__sel ,mark} and constructors {0,cons,dbl,dbls,from,indx,nil,s,sel} + Applied Processor: WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny} + Details: The weightgap principle applies using the following nonconstant growth matrix-interpretation: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(a__dbl) = {1}, uargs(a__dbls) = {1}, uargs(a__indx) = {1}, uargs(a__sel) = {1,2} Following symbols are considered usable: all TcT has computed the following interpretation: p(0) = [0] p(a__dbl) = [1] x1 + [0] p(a__dbls) = [1] x1 + [5] p(a__from) = [0] p(a__indx) = [1] x1 + [1] p(a__sel) = [1] x1 + [1] x2 + [0] p(cons) = [0] p(dbl) = [0] p(dbls) = [0] p(from) = [0] p(indx) = [0] p(mark) = [0] p(nil) = [0] p(s) = [0] p(sel) = [0] Following rules are strictly oriented: a__indx(X1,X2) = [1] X1 + [1] > [0] = indx(X1,X2) a__indx(cons(X,Y),Z) = [1] > [0] = cons(sel(X,Z),indx(Y,Z)) a__indx(nil(),X) = [1] > [0] = nil() Following rules are (at-least) weakly oriented: a__dbl(X) = [1] X + [0] >= [0] = dbl(X) a__dbl(0()) = [0] >= [0] = 0() a__dbl(s(X)) = [0] >= [0] = s(s(dbl(X))) a__dbls(X) = [1] X + [5] >= [0] = dbls(X) a__dbls(cons(X,Y)) = [5] >= [0] = cons(dbl(X),dbls(Y)) a__dbls(nil()) = [5] >= [0] = nil() a__from(X) = [0] >= [0] = cons(X,from(s(X))) a__from(X) = [0] >= [0] = from(X) a__sel(X1,X2) = [1] X1 + [1] X2 + [0] >= [0] = sel(X1,X2) a__sel(0(),cons(X,Y)) = [0] >= [0] = mark(X) a__sel(s(X),cons(Y,Z)) = [0] >= [0] = a__sel(mark(X),mark(Z)) mark(0()) = [0] >= [0] = 0() mark(cons(X1,X2)) = [0] >= [0] = cons(X1,X2) mark(dbl(X)) = [0] >= [0] = a__dbl(mark(X)) mark(dbls(X)) = [0] >= [5] = a__dbls(mark(X)) mark(from(X)) = [0] >= [0] = a__from(X) mark(indx(X1,X2)) = [0] >= [1] = a__indx(mark(X1),X2) mark(nil()) = [0] >= [0] = nil() mark(s(X)) = [0] >= [0] = s(X) mark(sel(X1,X2)) = [0] >= [0] = a__sel(mark(X1),mark(X2)) Further, it can be verified that all rules not oriented are covered by the weightgap condition. * Step 3: WeightGap MAYBE + Considered Problem: - Strict TRS: a__from(X) -> cons(X,from(s(X))) a__from(X) -> from(X) a__sel(X1,X2) -> sel(X1,X2) a__sel(0(),cons(X,Y)) -> mark(X) a__sel(s(X),cons(Y,Z)) -> a__sel(mark(X),mark(Z)) mark(dbl(X)) -> a__dbl(mark(X)) mark(dbls(X)) -> a__dbls(mark(X)) mark(indx(X1,X2)) -> a__indx(mark(X1),X2) mark(sel(X1,X2)) -> a__sel(mark(X1),mark(X2)) - Weak TRS: a__dbl(X) -> dbl(X) a__dbl(0()) -> 0() a__dbl(s(X)) -> s(s(dbl(X))) a__dbls(X) -> dbls(X) a__dbls(cons(X,Y)) -> cons(dbl(X),dbls(Y)) a__dbls(nil()) -> nil() a__indx(X1,X2) -> indx(X1,X2) a__indx(cons(X,Y),Z) -> cons(sel(X,Z),indx(Y,Z)) a__indx(nil(),X) -> nil() mark(0()) -> 0() mark(cons(X1,X2)) -> cons(X1,X2) mark(from(X)) -> a__from(X) mark(nil()) -> nil() mark(s(X)) -> s(X) - Signature: {a__dbl/1,a__dbls/1,a__from/1,a__indx/2,a__sel/2,mark/1} / {0/0,cons/2,dbl/1,dbls/1,from/1,indx/2,nil/0,s/1 ,sel/2} - Obligation: innermost runtime complexity wrt. defined symbols {a__dbl,a__dbls,a__from,a__indx,a__sel ,mark} and constructors {0,cons,dbl,dbls,from,indx,nil,s,sel} + Applied Processor: WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny} + Details: The weightgap principle applies using the following nonconstant growth matrix-interpretation: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(a__dbl) = {1}, uargs(a__dbls) = {1}, uargs(a__indx) = {1}, uargs(a__sel) = {1,2} Following symbols are considered usable: all TcT has computed the following interpretation: p(0) = [2] p(a__dbl) = [1] x1 + [0] p(a__dbls) = [1] x1 + [6] p(a__from) = [2] p(a__indx) = [1] x1 + [6] p(a__sel) = [1] x1 + [1] x2 + [5] p(cons) = [0] p(dbl) = [1] x1 + [0] p(dbls) = [0] p(from) = [0] p(indx) = [0] p(mark) = [2] p(nil) = [1] p(s) = [1] p(sel) = [1] x1 + [1] x2 + [0] Following rules are strictly oriented: a__from(X) = [2] > [0] = cons(X,from(s(X))) a__from(X) = [2] > [0] = from(X) a__sel(X1,X2) = [1] X1 + [1] X2 + [5] > [1] X1 + [1] X2 + [0] = sel(X1,X2) a__sel(0(),cons(X,Y)) = [7] > [2] = mark(X) Following rules are (at-least) weakly oriented: a__dbl(X) = [1] X + [0] >= [1] X + [0] = dbl(X) a__dbl(0()) = [2] >= [2] = 0() a__dbl(s(X)) = [1] >= [1] = s(s(dbl(X))) a__dbls(X) = [1] X + [6] >= [0] = dbls(X) a__dbls(cons(X,Y)) = [6] >= [0] = cons(dbl(X),dbls(Y)) a__dbls(nil()) = [7] >= [1] = nil() a__indx(X1,X2) = [1] X1 + [6] >= [0] = indx(X1,X2) a__indx(cons(X,Y),Z) = [6] >= [0] = cons(sel(X,Z),indx(Y,Z)) a__indx(nil(),X) = [7] >= [1] = nil() a__sel(s(X),cons(Y,Z)) = [6] >= [9] = a__sel(mark(X),mark(Z)) mark(0()) = [2] >= [2] = 0() mark(cons(X1,X2)) = [2] >= [0] = cons(X1,X2) mark(dbl(X)) = [2] >= [2] = a__dbl(mark(X)) mark(dbls(X)) = [2] >= [8] = a__dbls(mark(X)) mark(from(X)) = [2] >= [2] = a__from(X) mark(indx(X1,X2)) = [2] >= [8] = a__indx(mark(X1),X2) mark(nil()) = [2] >= [1] = nil() mark(s(X)) = [2] >= [1] = s(X) mark(sel(X1,X2)) = [2] >= [9] = a__sel(mark(X1),mark(X2)) Further, it can be verified that all rules not oriented are covered by the weightgap condition. * Step 4: Failure MAYBE + Considered Problem: - Strict TRS: a__sel(s(X),cons(Y,Z)) -> a__sel(mark(X),mark(Z)) mark(dbl(X)) -> a__dbl(mark(X)) mark(dbls(X)) -> a__dbls(mark(X)) mark(indx(X1,X2)) -> a__indx(mark(X1),X2) mark(sel(X1,X2)) -> a__sel(mark(X1),mark(X2)) - Weak TRS: a__dbl(X) -> dbl(X) a__dbl(0()) -> 0() a__dbl(s(X)) -> s(s(dbl(X))) a__dbls(X) -> dbls(X) a__dbls(cons(X,Y)) -> cons(dbl(X),dbls(Y)) a__dbls(nil()) -> nil() a__from(X) -> cons(X,from(s(X))) a__from(X) -> from(X) a__indx(X1,X2) -> indx(X1,X2) a__indx(cons(X,Y),Z) -> cons(sel(X,Z),indx(Y,Z)) a__indx(nil(),X) -> nil() a__sel(X1,X2) -> sel(X1,X2) a__sel(0(),cons(X,Y)) -> mark(X) mark(0()) -> 0() mark(cons(X1,X2)) -> cons(X1,X2) mark(from(X)) -> a__from(X) mark(nil()) -> nil() mark(s(X)) -> s(X) - Signature: {a__dbl/1,a__dbls/1,a__from/1,a__indx/2,a__sel/2,mark/1} / {0/0,cons/2,dbl/1,dbls/1,from/1,indx/2,nil/0,s/1 ,sel/2} - Obligation: innermost runtime complexity wrt. defined symbols {a__dbl,a__dbls,a__from,a__indx,a__sel ,mark} and constructors {0,cons,dbl,dbls,from,indx,nil,s,sel} + Applied Processor: EmptyProcessor + Details: The problem is still open. MAYBE