YES proof of /export/starexec/sandbox2/benchmark/theBenchmark.xml # AProVE Commit ID: 794c25de1cacf0d048858bcd21c9a779e1221865 marcel 20200619 unpublished dirty Termination of the given ETRS could be proven: (0) ETRS (1) EquationalDependencyPairsProof [EQUIVALENT, 98 ms] (2) EDP (3) EDependencyGraphProof [EQUIVALENT, 4 ms] (4) AND (5) EDP (6) ESharpUsableEquationsProof [EQUIVALENT, 0 ms] (7) EDP (8) EUsableRulesReductionPairsProof [EQUIVALENT, 62 ms] (9) EDP (10) PisEmptyProof [EQUIVALENT, 0 ms] (11) YES (12) EDP (13) ESharpUsableEquationsProof [EQUIVALENT, 0 ms] (14) EDP (15) EUsableRulesReductionPairsProof [EQUIVALENT, 87 ms] (16) EDP (17) EDependencyGraphProof [EQUIVALENT, 0 ms] (18) TRUE (19) EDP (20) ESharpUsableEquationsProof [EQUIVALENT, 17 ms] (21) EDP (22) EDPPoloProof [EQUIVALENT, 408 ms] (23) EDP (24) EDependencyGraphProof [EQUIVALENT, 0 ms] (25) EDP (26) EDPPoloProof [EQUIVALENT, 304 ms] (27) EDP (28) EDPPoloProof [EQUIVALENT, 233 ms] (29) EDP (30) EDependencyGraphProof [EQUIVALENT, 0 ms] (31) EDP (32) EDPPoloProof [EQUIVALENT, 214 ms] (33) EDP (34) PisEmptyProof [EQUIVALENT, 0 ms] (35) YES (36) EDP (37) ESharpUsableEquationsProof [EQUIVALENT, 0 ms] (38) EDP (39) EUsableRulesReductionPairsProof [EQUIVALENT, 22 ms] (40) EDP (41) EDependencyGraphProof [EQUIVALENT, 0 ms] (42) TRUE (43) EDP (44) ESharpUsableEquationsProof [EQUIVALENT, 0 ms] (45) EDP (46) EDPPoloProof [EQUIVALENT, 61.9 s] (47) EDP (48) EDependencyGraphProof [EQUIVALENT, 0 ms] (49) EDP (50) EDPPoloProof [EQUIVALENT, 52.4 s] (51) EDP (52) EDependencyGraphProof [EQUIVALENT, 0 ms] (53) EDP (54) EDPPoloProof [EQUIVALENT, 331 ms] (55) EDP (56) EDPPoloProof [EQUIVALENT, 265 ms] (57) EDP (58) PisEmptyProof [EQUIVALENT, 0 ms] (59) YES (60) EDP (61) ESharpUsableEquationsProof [EQUIVALENT, 0 ms] (62) EDP (63) EUsableRulesReductionPairsProof [EQUIVALENT, 0 ms] (64) EDP (65) EDependencyGraphProof [EQUIVALENT, 0 ms] (66) TRUE ---------------------------------------- (0) Obligation: Equational rewrite system: The TRS R consists of the following rules: union(X, empty) -> X union(empty, X) -> X 0(z) -> z U101(tt, X, Y) -> 0(mult(X, Y)) U11(tt, V1) -> U12(isBin(V1)) U111(tt, X, Y) -> plus(0(mult(X, Y)), Y) U12(tt) -> tt U121(tt, X) -> X U131(tt, X, Y) -> 0(plus(X, Y)) U141(tt, X, Y) -> 1(plus(X, Y)) U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) U161(tt, X) -> X U171(tt, A, B) -> mult(prod(A), prod(B)) U181(tt, X) -> X U191(tt, A, B) -> plus(sum(A), sum(B)) U21(tt, V1, V2) -> U22(isBag(V1), V2) U22(tt, V2) -> U23(isBag(V2)) U23(tt) -> tt U31(tt, V1) -> U32(isBin(V1)) U32(tt) -> tt U41(tt, V1) -> U42(isBin(V1)) U42(tt) -> tt U51(tt, V1, V2) -> U52(isBin(V1), V2) U52(tt, V2) -> U53(isBin(V2)) U53(tt) -> tt U61(tt, V1, V2) -> U62(isBin(V1), V2) U62(tt, V2) -> U63(isBin(V2)) U63(tt) -> tt U71(tt, V1) -> U72(isBag(V1)) U72(tt) -> tt U81(tt, V1) -> U82(isBag(V1)) U82(tt) -> tt U91(tt) -> z and(tt, X) -> X isBag(empty) -> tt isBag(singl(V1)) -> U11(isBinKind(V1), V1) isBag(union(V1, V2)) -> U21(and(isBagKind(V1), isBagKind(V2)), V1, V2) isBagKind(empty) -> tt isBagKind(singl(V1)) -> isBinKind(V1) isBagKind(union(V1, V2)) -> and(isBagKind(V1), isBagKind(V2)) isBin(z) -> tt isBin(0(V1)) -> U31(isBinKind(V1), V1) isBin(1(V1)) -> U41(isBinKind(V1), V1) isBin(mult(V1, V2)) -> U51(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(plus(V1, V2)) -> U61(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(prod(V1)) -> U71(isBagKind(V1), V1) isBin(sum(V1)) -> U81(isBagKind(V1), V1) isBinKind(z) -> tt isBinKind(0(V1)) -> isBinKind(V1) isBinKind(1(V1)) -> isBinKind(V1) isBinKind(mult(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(plus(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(prod(V1)) -> isBagKind(V1) isBinKind(sum(V1)) -> isBagKind(V1) mult(z, X) -> U91(and(isBin(X), isBinKind(X))) mult(0(X), Y) -> U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(1(X), Y) -> U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) prod(empty) -> 1(z) prod(singl(X)) -> U161(and(isBin(X), isBinKind(X)), X) prod(union(A, B)) -> U171(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) sum(empty) -> 0(z) sum(singl(X)) -> U181(and(isBin(X), isBinKind(X)), X) sum(union(A, B)) -> U191(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) The set E consists of the following equations: mult(x, y) == mult(y, x) plus(x, y) == plus(y, x) union(x, y) == union(y, x) mult(mult(x, y), z') == mult(x, mult(y, z')) plus(plus(x, y), z') == plus(x, plus(y, z')) union(union(x, y), z') == union(x, union(y, z')) ---------------------------------------- (1) EquationalDependencyPairsProof (EQUIVALENT) Using Dependency Pairs [AG00,DA_STEIN] we result in the following initial EDP problem: The TRS P consists of the following rules: U101^1(tt, X, Y) -> 0^1(mult(X, Y)) U101^1(tt, X, Y) -> MULT(X, Y) U11^1(tt, V1) -> U12^1(isBin(V1)) U11^1(tt, V1) -> ISBIN(V1) U111^1(tt, X, Y) -> PLUS(0(mult(X, Y)), Y) U111^1(tt, X, Y) -> 0^1(mult(X, Y)) U111^1(tt, X, Y) -> MULT(X, Y) U131^1(tt, X, Y) -> 0^1(plus(X, Y)) U131^1(tt, X, Y) -> PLUS(X, Y) U141^1(tt, X, Y) -> PLUS(X, Y) U151^1(tt, X, Y) -> 0^1(plus(plus(X, Y), 1(z))) U151^1(tt, X, Y) -> PLUS(plus(X, Y), 1(z)) U151^1(tt, X, Y) -> PLUS(X, Y) U171^1(tt, A, B) -> MULT(prod(A), prod(B)) U171^1(tt, A, B) -> PROD(A) U171^1(tt, A, B) -> PROD(B) U191^1(tt, A, B) -> PLUS(sum(A), sum(B)) U191^1(tt, A, B) -> SUM(A) U191^1(tt, A, B) -> SUM(B) U21^1(tt, V1, V2) -> U22^1(isBag(V1), V2) U21^1(tt, V1, V2) -> ISBAG(V1) U22^1(tt, V2) -> U23^1(isBag(V2)) U22^1(tt, V2) -> ISBAG(V2) U31^1(tt, V1) -> U32^1(isBin(V1)) U31^1(tt, V1) -> ISBIN(V1) U41^1(tt, V1) -> U42^1(isBin(V1)) U41^1(tt, V1) -> ISBIN(V1) U51^1(tt, V1, V2) -> U52^1(isBin(V1), V2) U51^1(tt, V1, V2) -> ISBIN(V1) U52^1(tt, V2) -> U53^1(isBin(V2)) U52^1(tt, V2) -> ISBIN(V2) U61^1(tt, V1, V2) -> U62^1(isBin(V1), V2) U61^1(tt, V1, V2) -> ISBIN(V1) U62^1(tt, V2) -> U63^1(isBin(V2)) U62^1(tt, V2) -> ISBIN(V2) U71^1(tt, V1) -> U72^1(isBag(V1)) U71^1(tt, V1) -> ISBAG(V1) U81^1(tt, V1) -> U82^1(isBag(V1)) U81^1(tt, V1) -> ISBAG(V1) ISBAG(singl(V1)) -> U11^1(isBinKind(V1), V1) ISBAG(singl(V1)) -> ISBINKIND(V1) ISBAG(union(V1, V2)) -> U21^1(and(isBagKind(V1), isBagKind(V2)), V1, V2) ISBAG(union(V1, V2)) -> AND(isBagKind(V1), isBagKind(V2)) ISBAG(union(V1, V2)) -> ISBAGKIND(V1) ISBAG(union(V1, V2)) -> ISBAGKIND(V2) ISBAGKIND(singl(V1)) -> ISBINKIND(V1) ISBAGKIND(union(V1, V2)) -> AND(isBagKind(V1), isBagKind(V2)) ISBAGKIND(union(V1, V2)) -> ISBAGKIND(V1) ISBAGKIND(union(V1, V2)) -> ISBAGKIND(V2) ISBIN(0(V1)) -> U31^1(isBinKind(V1), V1) ISBIN(0(V1)) -> ISBINKIND(V1) ISBIN(1(V1)) -> U41^1(isBinKind(V1), V1) ISBIN(1(V1)) -> ISBINKIND(V1) ISBIN(mult(V1, V2)) -> U51^1(and(isBinKind(V1), isBinKind(V2)), V1, V2) ISBIN(mult(V1, V2)) -> AND(isBinKind(V1), isBinKind(V2)) ISBIN(mult(V1, V2)) -> ISBINKIND(V1) ISBIN(mult(V1, V2)) -> ISBINKIND(V2) ISBIN(plus(V1, V2)) -> U61^1(and(isBinKind(V1), isBinKind(V2)), V1, V2) ISBIN(plus(V1, V2)) -> AND(isBinKind(V1), isBinKind(V2)) ISBIN(plus(V1, V2)) -> ISBINKIND(V1) ISBIN(plus(V1, V2)) -> ISBINKIND(V2) ISBIN(prod(V1)) -> U71^1(isBagKind(V1), V1) ISBIN(prod(V1)) -> ISBAGKIND(V1) ISBIN(sum(V1)) -> U81^1(isBagKind(V1), V1) ISBIN(sum(V1)) -> ISBAGKIND(V1) ISBINKIND(0(V1)) -> ISBINKIND(V1) ISBINKIND(1(V1)) -> ISBINKIND(V1) ISBINKIND(mult(V1, V2)) -> AND(isBinKind(V1), isBinKind(V2)) ISBINKIND(mult(V1, V2)) -> ISBINKIND(V1) ISBINKIND(mult(V1, V2)) -> ISBINKIND(V2) ISBINKIND(plus(V1, V2)) -> AND(isBinKind(V1), isBinKind(V2)) ISBINKIND(plus(V1, V2)) -> ISBINKIND(V1) ISBINKIND(plus(V1, V2)) -> ISBINKIND(V2) ISBINKIND(prod(V1)) -> ISBAGKIND(V1) ISBINKIND(sum(V1)) -> ISBAGKIND(V1) MULT(z, X) -> U91^1(and(isBin(X), isBinKind(X))) MULT(z, X) -> AND(isBin(X), isBinKind(X)) MULT(z, X) -> ISBIN(X) MULT(z, X) -> ISBINKIND(X) MULT(0(X), Y) -> U101^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) MULT(0(X), Y) -> AND(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))) MULT(0(X), Y) -> AND(isBin(X), isBinKind(X)) MULT(0(X), Y) -> ISBIN(X) MULT(0(X), Y) -> ISBINKIND(X) MULT(0(X), Y) -> AND(isBin(Y), isBinKind(Y)) MULT(0(X), Y) -> ISBIN(Y) MULT(0(X), Y) -> ISBINKIND(Y) MULT(1(X), Y) -> U111^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) MULT(1(X), Y) -> AND(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))) MULT(1(X), Y) -> AND(isBin(X), isBinKind(X)) MULT(1(X), Y) -> ISBIN(X) MULT(1(X), Y) -> ISBINKIND(X) MULT(1(X), Y) -> AND(isBin(Y), isBinKind(Y)) MULT(1(X), Y) -> ISBIN(Y) MULT(1(X), Y) -> ISBINKIND(Y) PLUS(z, X) -> U121^1(and(isBin(X), isBinKind(X)), X) PLUS(z, X) -> AND(isBin(X), isBinKind(X)) PLUS(z, X) -> ISBIN(X) PLUS(z, X) -> ISBINKIND(X) PLUS(0(X), 0(Y)) -> U131^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) PLUS(0(X), 0(Y)) -> AND(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))) PLUS(0(X), 0(Y)) -> AND(isBin(X), isBinKind(X)) PLUS(0(X), 0(Y)) -> ISBIN(X) PLUS(0(X), 0(Y)) -> ISBINKIND(X) PLUS(0(X), 0(Y)) -> AND(isBin(Y), isBinKind(Y)) PLUS(0(X), 0(Y)) -> ISBIN(Y) PLUS(0(X), 0(Y)) -> ISBINKIND(Y) PLUS(0(X), 1(Y)) -> U141^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) PLUS(0(X), 1(Y)) -> AND(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))) PLUS(0(X), 1(Y)) -> AND(isBin(X), isBinKind(X)) PLUS(0(X), 1(Y)) -> ISBIN(X) PLUS(0(X), 1(Y)) -> ISBINKIND(X) PLUS(0(X), 1(Y)) -> AND(isBin(Y), isBinKind(Y)) PLUS(0(X), 1(Y)) -> ISBIN(Y) PLUS(0(X), 1(Y)) -> ISBINKIND(Y) PLUS(1(X), 1(Y)) -> U151^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) PLUS(1(X), 1(Y)) -> AND(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))) PLUS(1(X), 1(Y)) -> AND(isBin(X), isBinKind(X)) PLUS(1(X), 1(Y)) -> ISBIN(X) PLUS(1(X), 1(Y)) -> ISBINKIND(X) PLUS(1(X), 1(Y)) -> AND(isBin(Y), isBinKind(Y)) PLUS(1(X), 1(Y)) -> ISBIN(Y) PLUS(1(X), 1(Y)) -> ISBINKIND(Y) PROD(singl(X)) -> U161^1(and(isBin(X), isBinKind(X)), X) PROD(singl(X)) -> AND(isBin(X), isBinKind(X)) PROD(singl(X)) -> ISBIN(X) PROD(singl(X)) -> ISBINKIND(X) PROD(union(A, B)) -> U171^1(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) PROD(union(A, B)) -> AND(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))) PROD(union(A, B)) -> AND(isBag(A), isBagKind(A)) PROD(union(A, B)) -> ISBAG(A) PROD(union(A, B)) -> ISBAGKIND(A) PROD(union(A, B)) -> AND(isBag(B), isBagKind(B)) PROD(union(A, B)) -> ISBAG(B) PROD(union(A, B)) -> ISBAGKIND(B) SUM(empty) -> 0^1(z) SUM(singl(X)) -> U181^1(and(isBin(X), isBinKind(X)), X) SUM(singl(X)) -> AND(isBin(X), isBinKind(X)) SUM(singl(X)) -> ISBIN(X) SUM(singl(X)) -> ISBINKIND(X) SUM(union(A, B)) -> U191^1(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) SUM(union(A, B)) -> AND(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))) SUM(union(A, B)) -> AND(isBag(A), isBagKind(A)) SUM(union(A, B)) -> ISBAG(A) SUM(union(A, B)) -> ISBAGKIND(A) SUM(union(A, B)) -> AND(isBag(B), isBagKind(B)) SUM(union(A, B)) -> ISBAG(B) SUM(union(A, B)) -> ISBAGKIND(B) MULT(mult(z, X), ext) -> MULT(U91(and(isBin(X), isBinKind(X))), ext) MULT(mult(z, X), ext) -> U91^1(and(isBin(X), isBinKind(X))) MULT(mult(z, X), ext) -> AND(isBin(X), isBinKind(X)) MULT(mult(z, X), ext) -> ISBIN(X) MULT(mult(z, X), ext) -> ISBINKIND(X) MULT(mult(0(X), Y), ext) -> MULT(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) MULT(mult(0(X), Y), ext) -> U101^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) MULT(mult(0(X), Y), ext) -> AND(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))) MULT(mult(0(X), Y), ext) -> AND(isBin(X), isBinKind(X)) MULT(mult(0(X), Y), ext) -> ISBIN(X) MULT(mult(0(X), Y), ext) -> ISBINKIND(X) MULT(mult(0(X), Y), ext) -> AND(isBin(Y), isBinKind(Y)) MULT(mult(0(X), Y), ext) -> ISBIN(Y) MULT(mult(0(X), Y), ext) -> ISBINKIND(Y) MULT(mult(1(X), Y), ext) -> MULT(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) MULT(mult(1(X), Y), ext) -> U111^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) MULT(mult(1(X), Y), ext) -> AND(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))) MULT(mult(1(X), Y), ext) -> AND(isBin(X), isBinKind(X)) MULT(mult(1(X), Y), ext) -> ISBIN(X) MULT(mult(1(X), Y), ext) -> ISBINKIND(X) MULT(mult(1(X), Y), ext) -> AND(isBin(Y), isBinKind(Y)) MULT(mult(1(X), Y), ext) -> ISBIN(Y) MULT(mult(1(X), Y), ext) -> ISBINKIND(Y) PLUS(plus(z, X), ext) -> PLUS(U121(and(isBin(X), isBinKind(X)), X), ext) PLUS(plus(z, X), ext) -> U121^1(and(isBin(X), isBinKind(X)), X) PLUS(plus(z, X), ext) -> AND(isBin(X), isBinKind(X)) PLUS(plus(z, X), ext) -> ISBIN(X) PLUS(plus(z, X), ext) -> ISBINKIND(X) PLUS(plus(0(X), 0(Y)), ext) -> PLUS(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) PLUS(plus(0(X), 0(Y)), ext) -> U131^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) PLUS(plus(0(X), 0(Y)), ext) -> AND(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))) PLUS(plus(0(X), 0(Y)), ext) -> AND(isBin(X), isBinKind(X)) PLUS(plus(0(X), 0(Y)), ext) -> ISBIN(X) PLUS(plus(0(X), 0(Y)), ext) -> ISBINKIND(X) PLUS(plus(0(X), 0(Y)), ext) -> AND(isBin(Y), isBinKind(Y)) PLUS(plus(0(X), 0(Y)), ext) -> ISBIN(Y) PLUS(plus(0(X), 0(Y)), ext) -> ISBINKIND(Y) PLUS(plus(0(X), 1(Y)), ext) -> PLUS(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) PLUS(plus(0(X), 1(Y)), ext) -> U141^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) PLUS(plus(0(X), 1(Y)), ext) -> AND(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))) PLUS(plus(0(X), 1(Y)), ext) -> AND(isBin(X), isBinKind(X)) PLUS(plus(0(X), 1(Y)), ext) -> ISBIN(X) PLUS(plus(0(X), 1(Y)), ext) -> ISBINKIND(X) PLUS(plus(0(X), 1(Y)), ext) -> AND(isBin(Y), isBinKind(Y)) PLUS(plus(0(X), 1(Y)), ext) -> ISBIN(Y) PLUS(plus(0(X), 1(Y)), ext) -> ISBINKIND(Y) PLUS(plus(1(X), 1(Y)), ext) -> PLUS(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) PLUS(plus(1(X), 1(Y)), ext) -> U151^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) PLUS(plus(1(X), 1(Y)), ext) -> AND(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))) PLUS(plus(1(X), 1(Y)), ext) -> AND(isBin(X), isBinKind(X)) PLUS(plus(1(X), 1(Y)), ext) -> ISBIN(X) PLUS(plus(1(X), 1(Y)), ext) -> ISBINKIND(X) PLUS(plus(1(X), 1(Y)), ext) -> AND(isBin(Y), isBinKind(Y)) PLUS(plus(1(X), 1(Y)), ext) -> ISBIN(Y) PLUS(plus(1(X), 1(Y)), ext) -> ISBINKIND(Y) The TRS R consists of the following rules: union(X, empty) -> X union(empty, X) -> X 0(z) -> z U101(tt, X, Y) -> 0(mult(X, Y)) U11(tt, V1) -> U12(isBin(V1)) U111(tt, X, Y) -> plus(0(mult(X, Y)), Y) U12(tt) -> tt U121(tt, X) -> X U131(tt, X, Y) -> 0(plus(X, Y)) U141(tt, X, Y) -> 1(plus(X, Y)) U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) U161(tt, X) -> X U171(tt, A, B) -> mult(prod(A), prod(B)) U181(tt, X) -> X U191(tt, A, B) -> plus(sum(A), sum(B)) U21(tt, V1, V2) -> U22(isBag(V1), V2) U22(tt, V2) -> U23(isBag(V2)) U23(tt) -> tt U31(tt, V1) -> U32(isBin(V1)) U32(tt) -> tt U41(tt, V1) -> U42(isBin(V1)) U42(tt) -> tt U51(tt, V1, V2) -> U52(isBin(V1), V2) U52(tt, V2) -> U53(isBin(V2)) U53(tt) -> tt U61(tt, V1, V2) -> U62(isBin(V1), V2) U62(tt, V2) -> U63(isBin(V2)) U63(tt) -> tt U71(tt, V1) -> U72(isBag(V1)) U72(tt) -> tt U81(tt, V1) -> U82(isBag(V1)) U82(tt) -> tt U91(tt) -> z and(tt, X) -> X isBag(empty) -> tt isBag(singl(V1)) -> U11(isBinKind(V1), V1) isBag(union(V1, V2)) -> U21(and(isBagKind(V1), isBagKind(V2)), V1, V2) isBagKind(empty) -> tt isBagKind(singl(V1)) -> isBinKind(V1) isBagKind(union(V1, V2)) -> and(isBagKind(V1), isBagKind(V2)) isBin(z) -> tt isBin(0(V1)) -> U31(isBinKind(V1), V1) isBin(1(V1)) -> U41(isBinKind(V1), V1) isBin(mult(V1, V2)) -> U51(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(plus(V1, V2)) -> U61(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(prod(V1)) -> U71(isBagKind(V1), V1) isBin(sum(V1)) -> U81(isBagKind(V1), V1) isBinKind(z) -> tt isBinKind(0(V1)) -> isBinKind(V1) isBinKind(1(V1)) -> isBinKind(V1) isBinKind(mult(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(plus(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(prod(V1)) -> isBagKind(V1) isBinKind(sum(V1)) -> isBagKind(V1) mult(z, X) -> U91(and(isBin(X), isBinKind(X))) mult(0(X), Y) -> U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(1(X), Y) -> U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) prod(empty) -> 1(z) prod(singl(X)) -> U161(and(isBin(X), isBinKind(X)), X) prod(union(A, B)) -> U171(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) sum(empty) -> 0(z) sum(singl(X)) -> U181(and(isBin(X), isBinKind(X)), X) sum(union(A, B)) -> U191(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) mult(mult(z, X), ext) -> mult(U91(and(isBin(X), isBinKind(X))), ext) mult(mult(0(X), Y), ext) -> mult(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) mult(mult(1(X), Y), ext) -> mult(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The set E consists of the following equations: mult(x, y) == mult(y, x) plus(x, y) == plus(y, x) union(x, y) == union(y, x) mult(mult(x, y), z') == mult(x, mult(y, z')) plus(plus(x, y), z') == plus(x, plus(y, z')) union(union(x, y), z') == union(x, union(y, z')) The set E# consists of the following equations: MULT(x, y) == MULT(y, x) PLUS(x, y) == PLUS(y, x) UNION(x, y) == UNION(y, x) MULT(mult(x, y), z') == MULT(x, mult(y, z')) PLUS(plus(x, y), z') == PLUS(x, plus(y, z')) UNION(union(x, y), z') == UNION(x, union(y, z')) We have to consider all minimal (P,E#,R,E)-chains ---------------------------------------- (2) Obligation: The TRS P consists of the following rules: U101^1(tt, X, Y) -> 0^1(mult(X, Y)) U101^1(tt, X, Y) -> MULT(X, Y) U11^1(tt, V1) -> U12^1(isBin(V1)) U11^1(tt, V1) -> ISBIN(V1) U111^1(tt, X, Y) -> PLUS(0(mult(X, Y)), Y) U111^1(tt, X, Y) -> 0^1(mult(X, Y)) U111^1(tt, X, Y) -> MULT(X, Y) U131^1(tt, X, Y) -> 0^1(plus(X, Y)) U131^1(tt, X, Y) -> PLUS(X, Y) U141^1(tt, X, Y) -> PLUS(X, Y) U151^1(tt, X, Y) -> 0^1(plus(plus(X, Y), 1(z))) U151^1(tt, X, Y) -> PLUS(plus(X, Y), 1(z)) U151^1(tt, X, Y) -> PLUS(X, Y) U171^1(tt, A, B) -> MULT(prod(A), prod(B)) U171^1(tt, A, B) -> PROD(A) U171^1(tt, A, B) -> PROD(B) U191^1(tt, A, B) -> PLUS(sum(A), sum(B)) U191^1(tt, A, B) -> SUM(A) U191^1(tt, A, B) -> SUM(B) U21^1(tt, V1, V2) -> U22^1(isBag(V1), V2) U21^1(tt, V1, V2) -> ISBAG(V1) U22^1(tt, V2) -> U23^1(isBag(V2)) U22^1(tt, V2) -> ISBAG(V2) U31^1(tt, V1) -> U32^1(isBin(V1)) U31^1(tt, V1) -> ISBIN(V1) U41^1(tt, V1) -> U42^1(isBin(V1)) U41^1(tt, V1) -> ISBIN(V1) U51^1(tt, V1, V2) -> U52^1(isBin(V1), V2) U51^1(tt, V1, V2) -> ISBIN(V1) U52^1(tt, V2) -> U53^1(isBin(V2)) U52^1(tt, V2) -> ISBIN(V2) U61^1(tt, V1, V2) -> U62^1(isBin(V1), V2) U61^1(tt, V1, V2) -> ISBIN(V1) U62^1(tt, V2) -> U63^1(isBin(V2)) U62^1(tt, V2) -> ISBIN(V2) U71^1(tt, V1) -> U72^1(isBag(V1)) U71^1(tt, V1) -> ISBAG(V1) U81^1(tt, V1) -> U82^1(isBag(V1)) U81^1(tt, V1) -> ISBAG(V1) ISBAG(singl(V1)) -> U11^1(isBinKind(V1), V1) ISBAG(singl(V1)) -> ISBINKIND(V1) ISBAG(union(V1, V2)) -> U21^1(and(isBagKind(V1), isBagKind(V2)), V1, V2) ISBAG(union(V1, V2)) -> AND(isBagKind(V1), isBagKind(V2)) ISBAG(union(V1, V2)) -> ISBAGKIND(V1) ISBAG(union(V1, V2)) -> ISBAGKIND(V2) ISBAGKIND(singl(V1)) -> ISBINKIND(V1) ISBAGKIND(union(V1, V2)) -> AND(isBagKind(V1), isBagKind(V2)) ISBAGKIND(union(V1, V2)) -> ISBAGKIND(V1) ISBAGKIND(union(V1, V2)) -> ISBAGKIND(V2) ISBIN(0(V1)) -> U31^1(isBinKind(V1), V1) ISBIN(0(V1)) -> ISBINKIND(V1) ISBIN(1(V1)) -> U41^1(isBinKind(V1), V1) ISBIN(1(V1)) -> ISBINKIND(V1) ISBIN(mult(V1, V2)) -> U51^1(and(isBinKind(V1), isBinKind(V2)), V1, V2) ISBIN(mult(V1, V2)) -> AND(isBinKind(V1), isBinKind(V2)) ISBIN(mult(V1, V2)) -> ISBINKIND(V1) ISBIN(mult(V1, V2)) -> ISBINKIND(V2) ISBIN(plus(V1, V2)) -> U61^1(and(isBinKind(V1), isBinKind(V2)), V1, V2) ISBIN(plus(V1, V2)) -> AND(isBinKind(V1), isBinKind(V2)) ISBIN(plus(V1, V2)) -> ISBINKIND(V1) ISBIN(plus(V1, V2)) -> ISBINKIND(V2) ISBIN(prod(V1)) -> U71^1(isBagKind(V1), V1) ISBIN(prod(V1)) -> ISBAGKIND(V1) ISBIN(sum(V1)) -> U81^1(isBagKind(V1), V1) ISBIN(sum(V1)) -> ISBAGKIND(V1) ISBINKIND(0(V1)) -> ISBINKIND(V1) ISBINKIND(1(V1)) -> ISBINKIND(V1) ISBINKIND(mult(V1, V2)) -> AND(isBinKind(V1), isBinKind(V2)) ISBINKIND(mult(V1, V2)) -> ISBINKIND(V1) ISBINKIND(mult(V1, V2)) -> ISBINKIND(V2) ISBINKIND(plus(V1, V2)) -> AND(isBinKind(V1), isBinKind(V2)) ISBINKIND(plus(V1, V2)) -> ISBINKIND(V1) ISBINKIND(plus(V1, V2)) -> ISBINKIND(V2) ISBINKIND(prod(V1)) -> ISBAGKIND(V1) ISBINKIND(sum(V1)) -> ISBAGKIND(V1) MULT(z, X) -> U91^1(and(isBin(X), isBinKind(X))) MULT(z, X) -> AND(isBin(X), isBinKind(X)) MULT(z, X) -> ISBIN(X) MULT(z, X) -> ISBINKIND(X) MULT(0(X), Y) -> U101^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) MULT(0(X), Y) -> AND(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))) MULT(0(X), Y) -> AND(isBin(X), isBinKind(X)) MULT(0(X), Y) -> ISBIN(X) MULT(0(X), Y) -> ISBINKIND(X) MULT(0(X), Y) -> AND(isBin(Y), isBinKind(Y)) MULT(0(X), Y) -> ISBIN(Y) MULT(0(X), Y) -> ISBINKIND(Y) MULT(1(X), Y) -> U111^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) MULT(1(X), Y) -> AND(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))) MULT(1(X), Y) -> AND(isBin(X), isBinKind(X)) MULT(1(X), Y) -> ISBIN(X) MULT(1(X), Y) -> ISBINKIND(X) MULT(1(X), Y) -> AND(isBin(Y), isBinKind(Y)) MULT(1(X), Y) -> ISBIN(Y) MULT(1(X), Y) -> ISBINKIND(Y) PLUS(z, X) -> U121^1(and(isBin(X), isBinKind(X)), X) PLUS(z, X) -> AND(isBin(X), isBinKind(X)) PLUS(z, X) -> ISBIN(X) PLUS(z, X) -> ISBINKIND(X) PLUS(0(X), 0(Y)) -> U131^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) PLUS(0(X), 0(Y)) -> AND(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))) PLUS(0(X), 0(Y)) -> AND(isBin(X), isBinKind(X)) PLUS(0(X), 0(Y)) -> ISBIN(X) PLUS(0(X), 0(Y)) -> ISBINKIND(X) PLUS(0(X), 0(Y)) -> AND(isBin(Y), isBinKind(Y)) PLUS(0(X), 0(Y)) -> ISBIN(Y) PLUS(0(X), 0(Y)) -> ISBINKIND(Y) PLUS(0(X), 1(Y)) -> U141^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) PLUS(0(X), 1(Y)) -> AND(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))) PLUS(0(X), 1(Y)) -> AND(isBin(X), isBinKind(X)) PLUS(0(X), 1(Y)) -> ISBIN(X) PLUS(0(X), 1(Y)) -> ISBINKIND(X) PLUS(0(X), 1(Y)) -> AND(isBin(Y), isBinKind(Y)) PLUS(0(X), 1(Y)) -> ISBIN(Y) PLUS(0(X), 1(Y)) -> ISBINKIND(Y) PLUS(1(X), 1(Y)) -> U151^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) PLUS(1(X), 1(Y)) -> AND(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))) PLUS(1(X), 1(Y)) -> AND(isBin(X), isBinKind(X)) PLUS(1(X), 1(Y)) -> ISBIN(X) PLUS(1(X), 1(Y)) -> ISBINKIND(X) PLUS(1(X), 1(Y)) -> AND(isBin(Y), isBinKind(Y)) PLUS(1(X), 1(Y)) -> ISBIN(Y) PLUS(1(X), 1(Y)) -> ISBINKIND(Y) PROD(singl(X)) -> U161^1(and(isBin(X), isBinKind(X)), X) PROD(singl(X)) -> AND(isBin(X), isBinKind(X)) PROD(singl(X)) -> ISBIN(X) PROD(singl(X)) -> ISBINKIND(X) PROD(union(A, B)) -> U171^1(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) PROD(union(A, B)) -> AND(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))) PROD(union(A, B)) -> AND(isBag(A), isBagKind(A)) PROD(union(A, B)) -> ISBAG(A) PROD(union(A, B)) -> ISBAGKIND(A) PROD(union(A, B)) -> AND(isBag(B), isBagKind(B)) PROD(union(A, B)) -> ISBAG(B) PROD(union(A, B)) -> ISBAGKIND(B) SUM(empty) -> 0^1(z) SUM(singl(X)) -> U181^1(and(isBin(X), isBinKind(X)), X) SUM(singl(X)) -> AND(isBin(X), isBinKind(X)) SUM(singl(X)) -> ISBIN(X) SUM(singl(X)) -> ISBINKIND(X) SUM(union(A, B)) -> U191^1(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) SUM(union(A, B)) -> AND(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))) SUM(union(A, B)) -> AND(isBag(A), isBagKind(A)) SUM(union(A, B)) -> ISBAG(A) SUM(union(A, B)) -> ISBAGKIND(A) SUM(union(A, B)) -> AND(isBag(B), isBagKind(B)) SUM(union(A, B)) -> ISBAG(B) SUM(union(A, B)) -> ISBAGKIND(B) MULT(mult(z, X), ext) -> MULT(U91(and(isBin(X), isBinKind(X))), ext) MULT(mult(z, X), ext) -> U91^1(and(isBin(X), isBinKind(X))) MULT(mult(z, X), ext) -> AND(isBin(X), isBinKind(X)) MULT(mult(z, X), ext) -> ISBIN(X) MULT(mult(z, X), ext) -> ISBINKIND(X) MULT(mult(0(X), Y), ext) -> MULT(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) MULT(mult(0(X), Y), ext) -> U101^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) MULT(mult(0(X), Y), ext) -> AND(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))) MULT(mult(0(X), Y), ext) -> AND(isBin(X), isBinKind(X)) MULT(mult(0(X), Y), ext) -> ISBIN(X) MULT(mult(0(X), Y), ext) -> ISBINKIND(X) MULT(mult(0(X), Y), ext) -> AND(isBin(Y), isBinKind(Y)) MULT(mult(0(X), Y), ext) -> ISBIN(Y) MULT(mult(0(X), Y), ext) -> ISBINKIND(Y) MULT(mult(1(X), Y), ext) -> MULT(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) MULT(mult(1(X), Y), ext) -> U111^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) MULT(mult(1(X), Y), ext) -> AND(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))) MULT(mult(1(X), Y), ext) -> AND(isBin(X), isBinKind(X)) MULT(mult(1(X), Y), ext) -> ISBIN(X) MULT(mult(1(X), Y), ext) -> ISBINKIND(X) MULT(mult(1(X), Y), ext) -> AND(isBin(Y), isBinKind(Y)) MULT(mult(1(X), Y), ext) -> ISBIN(Y) MULT(mult(1(X), Y), ext) -> ISBINKIND(Y) PLUS(plus(z, X), ext) -> PLUS(U121(and(isBin(X), isBinKind(X)), X), ext) PLUS(plus(z, X), ext) -> U121^1(and(isBin(X), isBinKind(X)), X) PLUS(plus(z, X), ext) -> AND(isBin(X), isBinKind(X)) PLUS(plus(z, X), ext) -> ISBIN(X) PLUS(plus(z, X), ext) -> ISBINKIND(X) PLUS(plus(0(X), 0(Y)), ext) -> PLUS(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) PLUS(plus(0(X), 0(Y)), ext) -> U131^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) PLUS(plus(0(X), 0(Y)), ext) -> AND(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))) PLUS(plus(0(X), 0(Y)), ext) -> AND(isBin(X), isBinKind(X)) PLUS(plus(0(X), 0(Y)), ext) -> ISBIN(X) PLUS(plus(0(X), 0(Y)), ext) -> ISBINKIND(X) PLUS(plus(0(X), 0(Y)), ext) -> AND(isBin(Y), isBinKind(Y)) PLUS(plus(0(X), 0(Y)), ext) -> ISBIN(Y) PLUS(plus(0(X), 0(Y)), ext) -> ISBINKIND(Y) PLUS(plus(0(X), 1(Y)), ext) -> PLUS(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) PLUS(plus(0(X), 1(Y)), ext) -> U141^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) PLUS(plus(0(X), 1(Y)), ext) -> AND(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))) PLUS(plus(0(X), 1(Y)), ext) -> AND(isBin(X), isBinKind(X)) PLUS(plus(0(X), 1(Y)), ext) -> ISBIN(X) PLUS(plus(0(X), 1(Y)), ext) -> ISBINKIND(X) PLUS(plus(0(X), 1(Y)), ext) -> AND(isBin(Y), isBinKind(Y)) PLUS(plus(0(X), 1(Y)), ext) -> ISBIN(Y) PLUS(plus(0(X), 1(Y)), ext) -> ISBINKIND(Y) PLUS(plus(1(X), 1(Y)), ext) -> PLUS(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) PLUS(plus(1(X), 1(Y)), ext) -> U151^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) PLUS(plus(1(X), 1(Y)), ext) -> AND(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))) PLUS(plus(1(X), 1(Y)), ext) -> AND(isBin(X), isBinKind(X)) PLUS(plus(1(X), 1(Y)), ext) -> ISBIN(X) PLUS(plus(1(X), 1(Y)), ext) -> ISBINKIND(X) PLUS(plus(1(X), 1(Y)), ext) -> AND(isBin(Y), isBinKind(Y)) PLUS(plus(1(X), 1(Y)), ext) -> ISBIN(Y) PLUS(plus(1(X), 1(Y)), ext) -> ISBINKIND(Y) The TRS R consists of the following rules: union(X, empty) -> X union(empty, X) -> X 0(z) -> z U101(tt, X, Y) -> 0(mult(X, Y)) U11(tt, V1) -> U12(isBin(V1)) U111(tt, X, Y) -> plus(0(mult(X, Y)), Y) U12(tt) -> tt U121(tt, X) -> X U131(tt, X, Y) -> 0(plus(X, Y)) U141(tt, X, Y) -> 1(plus(X, Y)) U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) U161(tt, X) -> X U171(tt, A, B) -> mult(prod(A), prod(B)) U181(tt, X) -> X U191(tt, A, B) -> plus(sum(A), sum(B)) U21(tt, V1, V2) -> U22(isBag(V1), V2) U22(tt, V2) -> U23(isBag(V2)) U23(tt) -> tt U31(tt, V1) -> U32(isBin(V1)) U32(tt) -> tt U41(tt, V1) -> U42(isBin(V1)) U42(tt) -> tt U51(tt, V1, V2) -> U52(isBin(V1), V2) U52(tt, V2) -> U53(isBin(V2)) U53(tt) -> tt U61(tt, V1, V2) -> U62(isBin(V1), V2) U62(tt, V2) -> U63(isBin(V2)) U63(tt) -> tt U71(tt, V1) -> U72(isBag(V1)) U72(tt) -> tt U81(tt, V1) -> U82(isBag(V1)) U82(tt) -> tt U91(tt) -> z and(tt, X) -> X isBag(empty) -> tt isBag(singl(V1)) -> U11(isBinKind(V1), V1) isBag(union(V1, V2)) -> U21(and(isBagKind(V1), isBagKind(V2)), V1, V2) isBagKind(empty) -> tt isBagKind(singl(V1)) -> isBinKind(V1) isBagKind(union(V1, V2)) -> and(isBagKind(V1), isBagKind(V2)) isBin(z) -> tt isBin(0(V1)) -> U31(isBinKind(V1), V1) isBin(1(V1)) -> U41(isBinKind(V1), V1) isBin(mult(V1, V2)) -> U51(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(plus(V1, V2)) -> U61(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(prod(V1)) -> U71(isBagKind(V1), V1) isBin(sum(V1)) -> U81(isBagKind(V1), V1) isBinKind(z) -> tt isBinKind(0(V1)) -> isBinKind(V1) isBinKind(1(V1)) -> isBinKind(V1) isBinKind(mult(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(plus(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(prod(V1)) -> isBagKind(V1) isBinKind(sum(V1)) -> isBagKind(V1) mult(z, X) -> U91(and(isBin(X), isBinKind(X))) mult(0(X), Y) -> U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(1(X), Y) -> U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) prod(empty) -> 1(z) prod(singl(X)) -> U161(and(isBin(X), isBinKind(X)), X) prod(union(A, B)) -> U171(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) sum(empty) -> 0(z) sum(singl(X)) -> U181(and(isBin(X), isBinKind(X)), X) sum(union(A, B)) -> U191(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) mult(mult(z, X), ext) -> mult(U91(and(isBin(X), isBinKind(X))), ext) mult(mult(0(X), Y), ext) -> mult(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) mult(mult(1(X), Y), ext) -> mult(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The set E consists of the following equations: mult(x, y) == mult(y, x) plus(x, y) == plus(y, x) union(x, y) == union(y, x) mult(mult(x, y), z') == mult(x, mult(y, z')) plus(plus(x, y), z') == plus(x, plus(y, z')) union(union(x, y), z') == union(x, union(y, z')) The set E# consists of the following equations: MULT(x, y) == MULT(y, x) PLUS(x, y) == PLUS(y, x) UNION(x, y) == UNION(y, x) MULT(mult(x, y), z') == MULT(x, mult(y, z')) PLUS(plus(x, y), z') == PLUS(x, plus(y, z')) UNION(union(x, y), z') == UNION(x, union(y, z')) We have to consider all minimal (P,E#,R,E)-chains ---------------------------------------- (3) EDependencyGraphProof (EQUIVALENT) The approximation of the Equational Dependency Graph [DA_STEIN] contains 6 SCCs with 141 less nodes. ---------------------------------------- (4) Complex Obligation (AND) ---------------------------------------- (5) Obligation: The TRS P consists of the following rules: ISBAGKIND(union(V1, V2)) -> ISBAGKIND(V1) ISBINKIND(0(V1)) -> ISBINKIND(V1) ISBINKIND(plus(V1, V2)) -> ISBINKIND(V2) ISBINKIND(1(V1)) -> ISBINKIND(V1) ISBINKIND(plus(V1, V2)) -> ISBINKIND(V1) ISBINKIND(sum(V1)) -> ISBAGKIND(V1) ISBINKIND(mult(V1, V2)) -> ISBINKIND(V2) ISBINKIND(prod(V1)) -> ISBAGKIND(V1) ISBAGKIND(union(V1, V2)) -> ISBAGKIND(V2) ISBINKIND(mult(V1, V2)) -> ISBINKIND(V1) ISBAGKIND(singl(V1)) -> ISBINKIND(V1) The TRS R consists of the following rules: union(X, empty) -> X union(empty, X) -> X 0(z) -> z U101(tt, X, Y) -> 0(mult(X, Y)) U11(tt, V1) -> U12(isBin(V1)) U111(tt, X, Y) -> plus(0(mult(X, Y)), Y) U12(tt) -> tt U121(tt, X) -> X U131(tt, X, Y) -> 0(plus(X, Y)) U141(tt, X, Y) -> 1(plus(X, Y)) U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) U161(tt, X) -> X U171(tt, A, B) -> mult(prod(A), prod(B)) U181(tt, X) -> X U191(tt, A, B) -> plus(sum(A), sum(B)) U21(tt, V1, V2) -> U22(isBag(V1), V2) U22(tt, V2) -> U23(isBag(V2)) U23(tt) -> tt U31(tt, V1) -> U32(isBin(V1)) U32(tt) -> tt U41(tt, V1) -> U42(isBin(V1)) U42(tt) -> tt U51(tt, V1, V2) -> U52(isBin(V1), V2) U52(tt, V2) -> U53(isBin(V2)) U53(tt) -> tt U61(tt, V1, V2) -> U62(isBin(V1), V2) U62(tt, V2) -> U63(isBin(V2)) U63(tt) -> tt U71(tt, V1) -> U72(isBag(V1)) U72(tt) -> tt U81(tt, V1) -> U82(isBag(V1)) U82(tt) -> tt U91(tt) -> z and(tt, X) -> X isBag(empty) -> tt isBag(singl(V1)) -> U11(isBinKind(V1), V1) isBag(union(V1, V2)) -> U21(and(isBagKind(V1), isBagKind(V2)), V1, V2) isBagKind(empty) -> tt isBagKind(singl(V1)) -> isBinKind(V1) isBagKind(union(V1, V2)) -> and(isBagKind(V1), isBagKind(V2)) isBin(z) -> tt isBin(0(V1)) -> U31(isBinKind(V1), V1) isBin(1(V1)) -> U41(isBinKind(V1), V1) isBin(mult(V1, V2)) -> U51(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(plus(V1, V2)) -> U61(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(prod(V1)) -> U71(isBagKind(V1), V1) isBin(sum(V1)) -> U81(isBagKind(V1), V1) isBinKind(z) -> tt isBinKind(0(V1)) -> isBinKind(V1) isBinKind(1(V1)) -> isBinKind(V1) isBinKind(mult(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(plus(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(prod(V1)) -> isBagKind(V1) isBinKind(sum(V1)) -> isBagKind(V1) mult(z, X) -> U91(and(isBin(X), isBinKind(X))) mult(0(X), Y) -> U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(1(X), Y) -> U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) prod(empty) -> 1(z) prod(singl(X)) -> U161(and(isBin(X), isBinKind(X)), X) prod(union(A, B)) -> U171(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) sum(empty) -> 0(z) sum(singl(X)) -> U181(and(isBin(X), isBinKind(X)), X) sum(union(A, B)) -> U191(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) mult(mult(z, X), ext) -> mult(U91(and(isBin(X), isBinKind(X))), ext) mult(mult(0(X), Y), ext) -> mult(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) mult(mult(1(X), Y), ext) -> mult(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The set E consists of the following equations: mult(x, y) == mult(y, x) plus(x, y) == plus(y, x) union(x, y) == union(y, x) mult(mult(x, y), z') == mult(x, mult(y, z')) plus(plus(x, y), z') == plus(x, plus(y, z')) union(union(x, y), z') == union(x, union(y, z')) The set E# consists of the following equations: MULT(x, y) == MULT(y, x) PLUS(x, y) == PLUS(y, x) UNION(x, y) == UNION(y, x) MULT(mult(x, y), z') == MULT(x, mult(y, z')) PLUS(plus(x, y), z') == PLUS(x, plus(y, z')) UNION(union(x, y), z') == UNION(x, union(y, z')) We have to consider all minimal (P,E#,R,E)-chains ---------------------------------------- (6) ESharpUsableEquationsProof (EQUIVALENT) We can delete the following equations of E# with the esharp usable equations processor[DA_STEIN]: MULT(x, y) == MULT(y, x) PLUS(x, y) == PLUS(y, x) UNION(x, y) == UNION(y, x) MULT(mult(x, y), z') == MULT(x, mult(y, z')) PLUS(plus(x, y), z') == PLUS(x, plus(y, z')) UNION(union(x, y), z') == UNION(x, union(y, z')) ---------------------------------------- (7) Obligation: The TRS P consists of the following rules: ISBAGKIND(union(V1, V2)) -> ISBAGKIND(V1) ISBINKIND(0(V1)) -> ISBINKIND(V1) ISBINKIND(plus(V1, V2)) -> ISBINKIND(V2) ISBINKIND(1(V1)) -> ISBINKIND(V1) ISBINKIND(plus(V1, V2)) -> ISBINKIND(V1) ISBINKIND(sum(V1)) -> ISBAGKIND(V1) ISBINKIND(mult(V1, V2)) -> ISBINKIND(V2) ISBINKIND(prod(V1)) -> ISBAGKIND(V1) ISBAGKIND(union(V1, V2)) -> ISBAGKIND(V2) ISBINKIND(mult(V1, V2)) -> ISBINKIND(V1) ISBAGKIND(singl(V1)) -> ISBINKIND(V1) The TRS R consists of the following rules: union(X, empty) -> X union(empty, X) -> X 0(z) -> z U101(tt, X, Y) -> 0(mult(X, Y)) U11(tt, V1) -> U12(isBin(V1)) U111(tt, X, Y) -> plus(0(mult(X, Y)), Y) U12(tt) -> tt U121(tt, X) -> X U131(tt, X, Y) -> 0(plus(X, Y)) U141(tt, X, Y) -> 1(plus(X, Y)) U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) U161(tt, X) -> X U171(tt, A, B) -> mult(prod(A), prod(B)) U181(tt, X) -> X U191(tt, A, B) -> plus(sum(A), sum(B)) U21(tt, V1, V2) -> U22(isBag(V1), V2) U22(tt, V2) -> U23(isBag(V2)) U23(tt) -> tt U31(tt, V1) -> U32(isBin(V1)) U32(tt) -> tt U41(tt, V1) -> U42(isBin(V1)) U42(tt) -> tt U51(tt, V1, V2) -> U52(isBin(V1), V2) U52(tt, V2) -> U53(isBin(V2)) U53(tt) -> tt U61(tt, V1, V2) -> U62(isBin(V1), V2) U62(tt, V2) -> U63(isBin(V2)) U63(tt) -> tt U71(tt, V1) -> U72(isBag(V1)) U72(tt) -> tt U81(tt, V1) -> U82(isBag(V1)) U82(tt) -> tt U91(tt) -> z and(tt, X) -> X isBag(empty) -> tt isBag(singl(V1)) -> U11(isBinKind(V1), V1) isBag(union(V1, V2)) -> U21(and(isBagKind(V1), isBagKind(V2)), V1, V2) isBagKind(empty) -> tt isBagKind(singl(V1)) -> isBinKind(V1) isBagKind(union(V1, V2)) -> and(isBagKind(V1), isBagKind(V2)) isBin(z) -> tt isBin(0(V1)) -> U31(isBinKind(V1), V1) isBin(1(V1)) -> U41(isBinKind(V1), V1) isBin(mult(V1, V2)) -> U51(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(plus(V1, V2)) -> U61(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(prod(V1)) -> U71(isBagKind(V1), V1) isBin(sum(V1)) -> U81(isBagKind(V1), V1) isBinKind(z) -> tt isBinKind(0(V1)) -> isBinKind(V1) isBinKind(1(V1)) -> isBinKind(V1) isBinKind(mult(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(plus(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(prod(V1)) -> isBagKind(V1) isBinKind(sum(V1)) -> isBagKind(V1) mult(z, X) -> U91(and(isBin(X), isBinKind(X))) mult(0(X), Y) -> U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(1(X), Y) -> U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) prod(empty) -> 1(z) prod(singl(X)) -> U161(and(isBin(X), isBinKind(X)), X) prod(union(A, B)) -> U171(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) sum(empty) -> 0(z) sum(singl(X)) -> U181(and(isBin(X), isBinKind(X)), X) sum(union(A, B)) -> U191(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) mult(mult(z, X), ext) -> mult(U91(and(isBin(X), isBinKind(X))), ext) mult(mult(0(X), Y), ext) -> mult(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) mult(mult(1(X), Y), ext) -> mult(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The set E consists of the following equations: mult(x, y) == mult(y, x) plus(x, y) == plus(y, x) union(x, y) == union(y, x) mult(mult(x, y), z') == mult(x, mult(y, z')) plus(plus(x, y), z') == plus(x, plus(y, z')) union(union(x, y), z') == union(x, union(y, z')) E# is empty. We have to consider all minimal (P,E#,R,E)-chains ---------------------------------------- (8) EUsableRulesReductionPairsProof (EQUIVALENT) By using the usable rules and equations with reduction pair processor [DA_STEIN] with a polynomial ordering [POLO], all dependency pairs and the corresponding usable rules can be oriented non-strictly, the usable equations and the esharp equations can be oriented equivalently. All non-usable rules and equations are removed, and those dependency pairs and usable rules that have been oriented strictly or contain non-usable symbols in their left-hand side are removed as well. The following dependency pairs can be deleted: ISBAGKIND(union(V1, V2)) -> ISBAGKIND(V1) ISBINKIND(0(V1)) -> ISBINKIND(V1) ISBINKIND(plus(V1, V2)) -> ISBINKIND(V2) ISBINKIND(1(V1)) -> ISBINKIND(V1) ISBINKIND(plus(V1, V2)) -> ISBINKIND(V1) ISBINKIND(sum(V1)) -> ISBAGKIND(V1) ISBINKIND(mult(V1, V2)) -> ISBINKIND(V2) ISBINKIND(prod(V1)) -> ISBAGKIND(V1) ISBAGKIND(union(V1, V2)) -> ISBAGKIND(V2) ISBINKIND(mult(V1, V2)) -> ISBINKIND(V1) ISBAGKIND(singl(V1)) -> ISBINKIND(V1) The following rules are removed from R: union(X, empty) -> X union(empty, X) -> X 0(z) -> z U101(tt, X, Y) -> 0(mult(X, Y)) U11(tt, V1) -> U12(isBin(V1)) U111(tt, X, Y) -> plus(0(mult(X, Y)), Y) U12(tt) -> tt U121(tt, X) -> X U131(tt, X, Y) -> 0(plus(X, Y)) U141(tt, X, Y) -> 1(plus(X, Y)) U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) U161(tt, X) -> X U171(tt, A, B) -> mult(prod(A), prod(B)) U181(tt, X) -> X U191(tt, A, B) -> plus(sum(A), sum(B)) U21(tt, V1, V2) -> U22(isBag(V1), V2) U22(tt, V2) -> U23(isBag(V2)) U23(tt) -> tt U31(tt, V1) -> U32(isBin(V1)) U32(tt) -> tt U41(tt, V1) -> U42(isBin(V1)) U42(tt) -> tt U51(tt, V1, V2) -> U52(isBin(V1), V2) U52(tt, V2) -> U53(isBin(V2)) U53(tt) -> tt U61(tt, V1, V2) -> U62(isBin(V1), V2) U62(tt, V2) -> U63(isBin(V2)) U63(tt) -> tt U71(tt, V1) -> U72(isBag(V1)) U72(tt) -> tt U81(tt, V1) -> U82(isBag(V1)) U82(tt) -> tt U91(tt) -> z and(tt, X) -> X isBag(empty) -> tt isBag(singl(V1)) -> U11(isBinKind(V1), V1) isBag(union(V1, V2)) -> U21(and(isBagKind(V1), isBagKind(V2)), V1, V2) isBagKind(empty) -> tt isBagKind(singl(V1)) -> isBinKind(V1) isBagKind(union(V1, V2)) -> and(isBagKind(V1), isBagKind(V2)) isBin(z) -> tt isBin(0(V1)) -> U31(isBinKind(V1), V1) isBin(1(V1)) -> U41(isBinKind(V1), V1) isBin(mult(V1, V2)) -> U51(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(plus(V1, V2)) -> U61(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(prod(V1)) -> U71(isBagKind(V1), V1) isBin(sum(V1)) -> U81(isBagKind(V1), V1) isBinKind(z) -> tt isBinKind(0(V1)) -> isBinKind(V1) isBinKind(1(V1)) -> isBinKind(V1) isBinKind(mult(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(plus(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(prod(V1)) -> isBagKind(V1) isBinKind(sum(V1)) -> isBagKind(V1) mult(z, X) -> U91(and(isBin(X), isBinKind(X))) mult(0(X), Y) -> U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(1(X), Y) -> U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) prod(empty) -> 1(z) prod(singl(X)) -> U161(and(isBin(X), isBinKind(X)), X) prod(union(A, B)) -> U171(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) sum(empty) -> 0(z) sum(singl(X)) -> U181(and(isBin(X), isBinKind(X)), X) sum(union(A, B)) -> U191(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) mult(mult(z, X), ext) -> mult(U91(and(isBin(X), isBinKind(X))), ext) mult(mult(0(X), Y), ext) -> mult(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) mult(mult(1(X), Y), ext) -> mult(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The following equations are removed from E: mult(x, y) == mult(y, x) plus(x, y) == plus(y, x) union(x, y) == union(y, x) mult(mult(x, y), z') == mult(x, mult(y, z')) plus(plus(x, y), z') == plus(x, plus(y, z')) union(union(x, y), z') == union(x, union(y, z')) Used ordering: POLO with Polynomial interpretation [POLO]: POL(0(x_1)) = 3*x_1 POL(1(x_1)) = 3*x_1 POL(ISBAGKIND(x_1)) = x_1 POL(ISBINKIND(x_1)) = 2*x_1 POL(mult(x_1, x_2)) = 3*x_1 + 3*x_2 POL(plus(x_1, x_2)) = 3*x_1 + 3*x_2 POL(prod(x_1)) = 3*x_1 POL(singl(x_1)) = 3*x_1 POL(sum(x_1)) = 3*x_1 POL(union(x_1, x_2)) = 3*x_1 + 3*x_2 ---------------------------------------- (9) Obligation: P is empty. R is empty. E is empty. E# is empty. We have to consider all minimal (P,E#,R,E)-chains ---------------------------------------- (10) PisEmptyProof (EQUIVALENT) The TRS P is empty. Hence, there is no (P,E#,R,E) chain. ---------------------------------------- (11) YES ---------------------------------------- (12) Obligation: The TRS P consists of the following rules: U71^1(tt, V1) -> ISBAG(V1) U61^1(tt, V1, V2) -> U62^1(isBin(V1), V2) U51^1(tt, V1, V2) -> U52^1(isBin(V1), V2) ISBIN(1(V1)) -> U41^1(isBinKind(V1), V1) U52^1(tt, V2) -> ISBIN(V2) U41^1(tt, V1) -> ISBIN(V1) U21^1(tt, V1, V2) -> U22^1(isBag(V1), V2) U11^1(tt, V1) -> ISBIN(V1) ISBIN(plus(V1, V2)) -> U61^1(and(isBinKind(V1), isBinKind(V2)), V1, V2) ISBIN(0(V1)) -> U31^1(isBinKind(V1), V1) U81^1(tt, V1) -> ISBAG(V1) U51^1(tt, V1, V2) -> ISBIN(V1) ISBIN(prod(V1)) -> U71^1(isBagKind(V1), V1) ISBAG(singl(V1)) -> U11^1(isBinKind(V1), V1) ISBAG(union(V1, V2)) -> U21^1(and(isBagKind(V1), isBagKind(V2)), V1, V2) ISBIN(mult(V1, V2)) -> U51^1(and(isBinKind(V1), isBinKind(V2)), V1, V2) U22^1(tt, V2) -> ISBAG(V2) U31^1(tt, V1) -> ISBIN(V1) ISBIN(sum(V1)) -> U81^1(isBagKind(V1), V1) U61^1(tt, V1, V2) -> ISBIN(V1) U62^1(tt, V2) -> ISBIN(V2) U21^1(tt, V1, V2) -> ISBAG(V1) The TRS R consists of the following rules: union(X, empty) -> X union(empty, X) -> X 0(z) -> z U101(tt, X, Y) -> 0(mult(X, Y)) U11(tt, V1) -> U12(isBin(V1)) U111(tt, X, Y) -> plus(0(mult(X, Y)), Y) U12(tt) -> tt U121(tt, X) -> X U131(tt, X, Y) -> 0(plus(X, Y)) U141(tt, X, Y) -> 1(plus(X, Y)) U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) U161(tt, X) -> X U171(tt, A, B) -> mult(prod(A), prod(B)) U181(tt, X) -> X U191(tt, A, B) -> plus(sum(A), sum(B)) U21(tt, V1, V2) -> U22(isBag(V1), V2) U22(tt, V2) -> U23(isBag(V2)) U23(tt) -> tt U31(tt, V1) -> U32(isBin(V1)) U32(tt) -> tt U41(tt, V1) -> U42(isBin(V1)) U42(tt) -> tt U51(tt, V1, V2) -> U52(isBin(V1), V2) U52(tt, V2) -> U53(isBin(V2)) U53(tt) -> tt U61(tt, V1, V2) -> U62(isBin(V1), V2) U62(tt, V2) -> U63(isBin(V2)) U63(tt) -> tt U71(tt, V1) -> U72(isBag(V1)) U72(tt) -> tt U81(tt, V1) -> U82(isBag(V1)) U82(tt) -> tt U91(tt) -> z and(tt, X) -> X isBag(empty) -> tt isBag(singl(V1)) -> U11(isBinKind(V1), V1) isBag(union(V1, V2)) -> U21(and(isBagKind(V1), isBagKind(V2)), V1, V2) isBagKind(empty) -> tt isBagKind(singl(V1)) -> isBinKind(V1) isBagKind(union(V1, V2)) -> and(isBagKind(V1), isBagKind(V2)) isBin(z) -> tt isBin(0(V1)) -> U31(isBinKind(V1), V1) isBin(1(V1)) -> U41(isBinKind(V1), V1) isBin(mult(V1, V2)) -> U51(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(plus(V1, V2)) -> U61(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(prod(V1)) -> U71(isBagKind(V1), V1) isBin(sum(V1)) -> U81(isBagKind(V1), V1) isBinKind(z) -> tt isBinKind(0(V1)) -> isBinKind(V1) isBinKind(1(V1)) -> isBinKind(V1) isBinKind(mult(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(plus(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(prod(V1)) -> isBagKind(V1) isBinKind(sum(V1)) -> isBagKind(V1) mult(z, X) -> U91(and(isBin(X), isBinKind(X))) mult(0(X), Y) -> U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(1(X), Y) -> U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) prod(empty) -> 1(z) prod(singl(X)) -> U161(and(isBin(X), isBinKind(X)), X) prod(union(A, B)) -> U171(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) sum(empty) -> 0(z) sum(singl(X)) -> U181(and(isBin(X), isBinKind(X)), X) sum(union(A, B)) -> U191(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) mult(mult(z, X), ext) -> mult(U91(and(isBin(X), isBinKind(X))), ext) mult(mult(0(X), Y), ext) -> mult(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) mult(mult(1(X), Y), ext) -> mult(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The set E consists of the following equations: mult(x, y) == mult(y, x) plus(x, y) == plus(y, x) union(x, y) == union(y, x) mult(mult(x, y), z') == mult(x, mult(y, z')) plus(plus(x, y), z') == plus(x, plus(y, z')) union(union(x, y), z') == union(x, union(y, z')) The set E# consists of the following equations: MULT(x, y) == MULT(y, x) PLUS(x, y) == PLUS(y, x) UNION(x, y) == UNION(y, x) MULT(mult(x, y), z') == MULT(x, mult(y, z')) PLUS(plus(x, y), z') == PLUS(x, plus(y, z')) UNION(union(x, y), z') == UNION(x, union(y, z')) We have to consider all minimal (P,E#,R,E)-chains ---------------------------------------- (13) ESharpUsableEquationsProof (EQUIVALENT) We can delete the following equations of E# with the esharp usable equations processor[DA_STEIN]: MULT(x, y) == MULT(y, x) PLUS(x, y) == PLUS(y, x) UNION(x, y) == UNION(y, x) MULT(mult(x, y), z') == MULT(x, mult(y, z')) PLUS(plus(x, y), z') == PLUS(x, plus(y, z')) UNION(union(x, y), z') == UNION(x, union(y, z')) ---------------------------------------- (14) Obligation: The TRS P consists of the following rules: U71^1(tt, V1) -> ISBAG(V1) U61^1(tt, V1, V2) -> U62^1(isBin(V1), V2) U51^1(tt, V1, V2) -> U52^1(isBin(V1), V2) ISBIN(1(V1)) -> U41^1(isBinKind(V1), V1) U52^1(tt, V2) -> ISBIN(V2) U41^1(tt, V1) -> ISBIN(V1) U21^1(tt, V1, V2) -> U22^1(isBag(V1), V2) U11^1(tt, V1) -> ISBIN(V1) ISBIN(plus(V1, V2)) -> U61^1(and(isBinKind(V1), isBinKind(V2)), V1, V2) ISBIN(0(V1)) -> U31^1(isBinKind(V1), V1) U81^1(tt, V1) -> ISBAG(V1) U51^1(tt, V1, V2) -> ISBIN(V1) ISBIN(prod(V1)) -> U71^1(isBagKind(V1), V1) ISBAG(singl(V1)) -> U11^1(isBinKind(V1), V1) ISBAG(union(V1, V2)) -> U21^1(and(isBagKind(V1), isBagKind(V2)), V1, V2) ISBIN(mult(V1, V2)) -> U51^1(and(isBinKind(V1), isBinKind(V2)), V1, V2) U22^1(tt, V2) -> ISBAG(V2) U31^1(tt, V1) -> ISBIN(V1) ISBIN(sum(V1)) -> U81^1(isBagKind(V1), V1) U61^1(tt, V1, V2) -> ISBIN(V1) U62^1(tt, V2) -> ISBIN(V2) U21^1(tt, V1, V2) -> ISBAG(V1) The TRS R consists of the following rules: union(X, empty) -> X union(empty, X) -> X 0(z) -> z U101(tt, X, Y) -> 0(mult(X, Y)) U11(tt, V1) -> U12(isBin(V1)) U111(tt, X, Y) -> plus(0(mult(X, Y)), Y) U12(tt) -> tt U121(tt, X) -> X U131(tt, X, Y) -> 0(plus(X, Y)) U141(tt, X, Y) -> 1(plus(X, Y)) U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) U161(tt, X) -> X U171(tt, A, B) -> mult(prod(A), prod(B)) U181(tt, X) -> X U191(tt, A, B) -> plus(sum(A), sum(B)) U21(tt, V1, V2) -> U22(isBag(V1), V2) U22(tt, V2) -> U23(isBag(V2)) U23(tt) -> tt U31(tt, V1) -> U32(isBin(V1)) U32(tt) -> tt U41(tt, V1) -> U42(isBin(V1)) U42(tt) -> tt U51(tt, V1, V2) -> U52(isBin(V1), V2) U52(tt, V2) -> U53(isBin(V2)) U53(tt) -> tt U61(tt, V1, V2) -> U62(isBin(V1), V2) U62(tt, V2) -> U63(isBin(V2)) U63(tt) -> tt U71(tt, V1) -> U72(isBag(V1)) U72(tt) -> tt U81(tt, V1) -> U82(isBag(V1)) U82(tt) -> tt U91(tt) -> z and(tt, X) -> X isBag(empty) -> tt isBag(singl(V1)) -> U11(isBinKind(V1), V1) isBag(union(V1, V2)) -> U21(and(isBagKind(V1), isBagKind(V2)), V1, V2) isBagKind(empty) -> tt isBagKind(singl(V1)) -> isBinKind(V1) isBagKind(union(V1, V2)) -> and(isBagKind(V1), isBagKind(V2)) isBin(z) -> tt isBin(0(V1)) -> U31(isBinKind(V1), V1) isBin(1(V1)) -> U41(isBinKind(V1), V1) isBin(mult(V1, V2)) -> U51(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(plus(V1, V2)) -> U61(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(prod(V1)) -> U71(isBagKind(V1), V1) isBin(sum(V1)) -> U81(isBagKind(V1), V1) isBinKind(z) -> tt isBinKind(0(V1)) -> isBinKind(V1) isBinKind(1(V1)) -> isBinKind(V1) isBinKind(mult(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(plus(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(prod(V1)) -> isBagKind(V1) isBinKind(sum(V1)) -> isBagKind(V1) mult(z, X) -> U91(and(isBin(X), isBinKind(X))) mult(0(X), Y) -> U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(1(X), Y) -> U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) prod(empty) -> 1(z) prod(singl(X)) -> U161(and(isBin(X), isBinKind(X)), X) prod(union(A, B)) -> U171(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) sum(empty) -> 0(z) sum(singl(X)) -> U181(and(isBin(X), isBinKind(X)), X) sum(union(A, B)) -> U191(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) mult(mult(z, X), ext) -> mult(U91(and(isBin(X), isBinKind(X))), ext) mult(mult(0(X), Y), ext) -> mult(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) mult(mult(1(X), Y), ext) -> mult(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The set E consists of the following equations: mult(x, y) == mult(y, x) plus(x, y) == plus(y, x) union(x, y) == union(y, x) mult(mult(x, y), z') == mult(x, mult(y, z')) plus(plus(x, y), z') == plus(x, plus(y, z')) union(union(x, y), z') == union(x, union(y, z')) E# is empty. We have to consider all minimal (P,E#,R,E)-chains ---------------------------------------- (15) EUsableRulesReductionPairsProof (EQUIVALENT) By using the usable rules and equations with reduction pair processor [DA_STEIN] with a polynomial ordering [POLO], all dependency pairs and the corresponding usable rules can be oriented non-strictly, the usable equations and the esharp equations can be oriented equivalently. All non-usable rules and equations are removed, and those dependency pairs and usable rules that have been oriented strictly or contain non-usable symbols in their left-hand side are removed as well. The following dependency pairs can be deleted: ISBIN(1(V1)) -> U41^1(isBinKind(V1), V1) ISBIN(plus(V1, V2)) -> U61^1(and(isBinKind(V1), isBinKind(V2)), V1, V2) ISBIN(0(V1)) -> U31^1(isBinKind(V1), V1) ISBIN(prod(V1)) -> U71^1(isBagKind(V1), V1) ISBAG(singl(V1)) -> U11^1(isBinKind(V1), V1) ISBAG(union(V1, V2)) -> U21^1(and(isBagKind(V1), isBagKind(V2)), V1, V2) ISBIN(mult(V1, V2)) -> U51^1(and(isBinKind(V1), isBinKind(V2)), V1, V2) ISBIN(sum(V1)) -> U81^1(isBagKind(V1), V1) The following rules are removed from R: union(X, empty) -> X union(empty, X) -> X 0(z) -> z U101(tt, X, Y) -> 0(mult(X, Y)) U111(tt, X, Y) -> plus(0(mult(X, Y)), Y) U121(tt, X) -> X U131(tt, X, Y) -> 0(plus(X, Y)) U141(tt, X, Y) -> 1(plus(X, Y)) U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) U161(tt, X) -> X U171(tt, A, B) -> mult(prod(A), prod(B)) U181(tt, X) -> X U191(tt, A, B) -> plus(sum(A), sum(B)) U31(tt, V1) -> U32(isBin(V1)) U91(tt) -> z isBag(empty) -> tt isBag(singl(V1)) -> U11(isBinKind(V1), V1) isBag(union(V1, V2)) -> U21(and(isBagKind(V1), isBagKind(V2)), V1, V2) isBagKind(empty) -> tt isBagKind(singl(V1)) -> isBinKind(V1) isBagKind(union(V1, V2)) -> and(isBagKind(V1), isBagKind(V2)) isBin(z) -> tt isBin(0(V1)) -> U31(isBinKind(V1), V1) isBin(1(V1)) -> U41(isBinKind(V1), V1) isBin(mult(V1, V2)) -> U51(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(plus(V1, V2)) -> U61(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(prod(V1)) -> U71(isBagKind(V1), V1) isBin(sum(V1)) -> U81(isBagKind(V1), V1) isBinKind(z) -> tt isBinKind(0(V1)) -> isBinKind(V1) isBinKind(1(V1)) -> isBinKind(V1) isBinKind(mult(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(plus(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(prod(V1)) -> isBagKind(V1) isBinKind(sum(V1)) -> isBagKind(V1) mult(z, X) -> U91(and(isBin(X), isBinKind(X))) mult(0(X), Y) -> U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(1(X), Y) -> U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) prod(empty) -> 1(z) prod(singl(X)) -> U161(and(isBin(X), isBinKind(X)), X) prod(union(A, B)) -> U171(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) sum(empty) -> 0(z) sum(singl(X)) -> U181(and(isBin(X), isBinKind(X)), X) sum(union(A, B)) -> U191(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) mult(mult(z, X), ext) -> mult(U91(and(isBin(X), isBinKind(X))), ext) mult(mult(0(X), Y), ext) -> mult(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) mult(mult(1(X), Y), ext) -> mult(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The following equations are removed from E: mult(x, y) == mult(y, x) plus(x, y) == plus(y, x) union(x, y) == union(y, x) mult(mult(x, y), z') == mult(x, mult(y, z')) plus(plus(x, y), z') == plus(x, plus(y, z')) union(union(x, y), z') == union(x, union(y, z')) Used ordering: POLO with Polynomial interpretation [POLO]: POL(0(x_1)) = 2 + 3*x_1 POL(1(x_1)) = 2*x_1 POL(ISBAG(x_1)) = 2*x_1 POL(ISBIN(x_1)) = 2*x_1 POL(U11(x_1, x_2)) = x_1 + 2*x_2 POL(U11^1(x_1, x_2)) = 2*x_1 + 2*x_2 POL(U12(x_1)) = x_1 POL(U21(x_1, x_2, x_3)) = x_1 + 2*x_2 + 2*x_3 POL(U21^1(x_1, x_2, x_3)) = x_1 + 2*x_2 + 2*x_3 POL(U22(x_1, x_2)) = x_1 + 2*x_2 POL(U22^1(x_1, x_2)) = x_1 + 2*x_2 POL(U23(x_1)) = x_1 POL(U31(x_1, x_2)) = 2 + x_1 + 2*x_2 POL(U31^1(x_1, x_2)) = x_1 + 2*x_2 POL(U32(x_1)) = x_1 POL(U41(x_1, x_2)) = x_1 + 2*x_2 POL(U41^1(x_1, x_2)) = x_1 + 2*x_2 POL(U42(x_1)) = x_1 POL(U51(x_1, x_2, x_3)) = 2*x_1 + 2*x_2 + 2*x_3 POL(U51^1(x_1, x_2, x_3)) = x_1 + 2*x_2 + 2*x_3 POL(U52(x_1, x_2)) = x_1 + 2*x_2 POL(U52^1(x_1, x_2)) = x_1 + 2*x_2 POL(U53(x_1)) = x_1 POL(U61(x_1, x_2, x_3)) = x_1 + 2*x_2 + 2*x_3 POL(U61^1(x_1, x_2, x_3)) = x_1 + 2*x_2 + 2*x_3 POL(U62(x_1, x_2)) = x_1 + 2*x_2 POL(U62^1(x_1, x_2)) = x_1 + 2*x_2 POL(U63(x_1)) = x_1 POL(U71(x_1, x_2)) = 2*x_1 + 2*x_2 POL(U71^1(x_1, x_2)) = 2*x_1 + 2*x_2 POL(U72(x_1)) = x_1 POL(U81(x_1, x_2)) = x_1 + 2*x_2 POL(U81^1(x_1, x_2)) = x_1 + 2*x_2 POL(U82(x_1)) = x_1 POL(and(x_1, x_2)) = x_1 + x_2 POL(empty) = 0 POL(isBag(x_1)) = 2*x_1 POL(isBagKind(x_1)) = 2*x_1 POL(isBin(x_1)) = 2*x_1 POL(isBinKind(x_1)) = 2*x_1 POL(mult(x_1, x_2)) = 3*x_1 + 3*x_2 POL(plus(x_1, x_2)) = 2*x_1 + 3*x_2 POL(prod(x_1)) = 2 + 3*x_1 POL(singl(x_1)) = 3*x_1 POL(sum(x_1)) = 3 + 3*x_1 POL(tt) = 0 POL(union(x_1, x_2)) = 2 + 3*x_1 + 3*x_2 POL(z) = 0 ---------------------------------------- (16) Obligation: The TRS P consists of the following rules: U71^1(tt, V1) -> ISBAG(V1) U61^1(tt, V1, V2) -> U62^1(isBin(V1), V2) U51^1(tt, V1, V2) -> U52^1(isBin(V1), V2) U52^1(tt, V2) -> ISBIN(V2) U41^1(tt, V1) -> ISBIN(V1) U21^1(tt, V1, V2) -> U22^1(isBag(V1), V2) U11^1(tt, V1) -> ISBIN(V1) U81^1(tt, V1) -> ISBAG(V1) U51^1(tt, V1, V2) -> ISBIN(V1) U22^1(tt, V2) -> ISBAG(V2) U31^1(tt, V1) -> ISBIN(V1) U61^1(tt, V1, V2) -> ISBIN(V1) U62^1(tt, V2) -> ISBIN(V2) U21^1(tt, V1, V2) -> ISBAG(V1) The TRS R consists of the following rules: U51(tt, V1, V2) -> U52(isBin(V1), V2) U42(tt) -> tt and(tt, X) -> X U21(tt, V1, V2) -> U22(isBag(V1), V2) U82(tt) -> tt U41(tt, V1) -> U42(isBin(V1)) U11(tt, V1) -> U12(isBin(V1)) U72(tt) -> tt U52(tt, V2) -> U53(isBin(V2)) U23(tt) -> tt U71(tt, V1) -> U72(isBag(V1)) U22(tt, V2) -> U23(isBag(V2)) U12(tt) -> tt U32(tt) -> tt U61(tt, V1, V2) -> U62(isBin(V1), V2) U53(tt) -> tt U62(tt, V2) -> U63(isBin(V2)) U81(tt, V1) -> U82(isBag(V1)) U63(tt) -> tt E is empty. E# is empty. We have to consider all minimal (P,E#,R,E)-chains ---------------------------------------- (17) EDependencyGraphProof (EQUIVALENT) The approximation of the Equational Dependency Graph [DA_STEIN] contains 0 SCCs with 14 less nodes. ---------------------------------------- (18) TRUE ---------------------------------------- (19) Obligation: The TRS P consists of the following rules: U151^1(tt, X, Y) -> PLUS(X, Y) PLUS(plus(0(X), 1(Y)), ext) -> PLUS(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) PLUS(0(X), 1(Y)) -> U141^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) PLUS(plus(0(X), 1(Y)), ext) -> U141^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) U141^1(tt, X, Y) -> PLUS(X, Y) PLUS(1(X), 1(Y)) -> U151^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) PLUS(plus(0(X), 0(Y)), ext) -> PLUS(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) PLUS(plus(1(X), 1(Y)), ext) -> PLUS(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) PLUS(plus(1(X), 1(Y)), ext) -> U151^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) U151^1(tt, X, Y) -> PLUS(plus(X, Y), 1(z)) PLUS(plus(z, X), ext) -> PLUS(U121(and(isBin(X), isBinKind(X)), X), ext) PLUS(0(X), 0(Y)) -> U131^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) U131^1(tt, X, Y) -> PLUS(X, Y) PLUS(plus(0(X), 0(Y)), ext) -> U131^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) The TRS R consists of the following rules: union(X, empty) -> X union(empty, X) -> X 0(z) -> z U101(tt, X, Y) -> 0(mult(X, Y)) U11(tt, V1) -> U12(isBin(V1)) U111(tt, X, Y) -> plus(0(mult(X, Y)), Y) U12(tt) -> tt U121(tt, X) -> X U131(tt, X, Y) -> 0(plus(X, Y)) U141(tt, X, Y) -> 1(plus(X, Y)) U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) U161(tt, X) -> X U171(tt, A, B) -> mult(prod(A), prod(B)) U181(tt, X) -> X U191(tt, A, B) -> plus(sum(A), sum(B)) U21(tt, V1, V2) -> U22(isBag(V1), V2) U22(tt, V2) -> U23(isBag(V2)) U23(tt) -> tt U31(tt, V1) -> U32(isBin(V1)) U32(tt) -> tt U41(tt, V1) -> U42(isBin(V1)) U42(tt) -> tt U51(tt, V1, V2) -> U52(isBin(V1), V2) U52(tt, V2) -> U53(isBin(V2)) U53(tt) -> tt U61(tt, V1, V2) -> U62(isBin(V1), V2) U62(tt, V2) -> U63(isBin(V2)) U63(tt) -> tt U71(tt, V1) -> U72(isBag(V1)) U72(tt) -> tt U81(tt, V1) -> U82(isBag(V1)) U82(tt) -> tt U91(tt) -> z and(tt, X) -> X isBag(empty) -> tt isBag(singl(V1)) -> U11(isBinKind(V1), V1) isBag(union(V1, V2)) -> U21(and(isBagKind(V1), isBagKind(V2)), V1, V2) isBagKind(empty) -> tt isBagKind(singl(V1)) -> isBinKind(V1) isBagKind(union(V1, V2)) -> and(isBagKind(V1), isBagKind(V2)) isBin(z) -> tt isBin(0(V1)) -> U31(isBinKind(V1), V1) isBin(1(V1)) -> U41(isBinKind(V1), V1) isBin(mult(V1, V2)) -> U51(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(plus(V1, V2)) -> U61(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(prod(V1)) -> U71(isBagKind(V1), V1) isBin(sum(V1)) -> U81(isBagKind(V1), V1) isBinKind(z) -> tt isBinKind(0(V1)) -> isBinKind(V1) isBinKind(1(V1)) -> isBinKind(V1) isBinKind(mult(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(plus(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(prod(V1)) -> isBagKind(V1) isBinKind(sum(V1)) -> isBagKind(V1) mult(z, X) -> U91(and(isBin(X), isBinKind(X))) mult(0(X), Y) -> U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(1(X), Y) -> U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) prod(empty) -> 1(z) prod(singl(X)) -> U161(and(isBin(X), isBinKind(X)), X) prod(union(A, B)) -> U171(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) sum(empty) -> 0(z) sum(singl(X)) -> U181(and(isBin(X), isBinKind(X)), X) sum(union(A, B)) -> U191(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) mult(mult(z, X), ext) -> mult(U91(and(isBin(X), isBinKind(X))), ext) mult(mult(0(X), Y), ext) -> mult(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) mult(mult(1(X), Y), ext) -> mult(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The set E consists of the following equations: mult(x, y) == mult(y, x) plus(x, y) == plus(y, x) union(x, y) == union(y, x) mult(mult(x, y), z') == mult(x, mult(y, z')) plus(plus(x, y), z') == plus(x, plus(y, z')) union(union(x, y), z') == union(x, union(y, z')) The set E# consists of the following equations: MULT(x, y) == MULT(y, x) PLUS(x, y) == PLUS(y, x) UNION(x, y) == UNION(y, x) MULT(mult(x, y), z') == MULT(x, mult(y, z')) PLUS(plus(x, y), z') == PLUS(x, plus(y, z')) UNION(union(x, y), z') == UNION(x, union(y, z')) We have to consider all minimal (P,E#,R,E)-chains ---------------------------------------- (20) ESharpUsableEquationsProof (EQUIVALENT) We can delete the following equations of E# with the esharp usable equations processor[DA_STEIN]: MULT(x, y) == MULT(y, x) UNION(x, y) == UNION(y, x) MULT(mult(x, y), z') == MULT(x, mult(y, z')) UNION(union(x, y), z') == UNION(x, union(y, z')) ---------------------------------------- (21) Obligation: The TRS P consists of the following rules: U151^1(tt, X, Y) -> PLUS(X, Y) PLUS(plus(0(X), 1(Y)), ext) -> PLUS(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) PLUS(0(X), 1(Y)) -> U141^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) PLUS(plus(0(X), 1(Y)), ext) -> U141^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) U141^1(tt, X, Y) -> PLUS(X, Y) PLUS(1(X), 1(Y)) -> U151^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) PLUS(plus(0(X), 0(Y)), ext) -> PLUS(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) PLUS(plus(1(X), 1(Y)), ext) -> PLUS(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) PLUS(plus(1(X), 1(Y)), ext) -> U151^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) U151^1(tt, X, Y) -> PLUS(plus(X, Y), 1(z)) PLUS(plus(z, X), ext) -> PLUS(U121(and(isBin(X), isBinKind(X)), X), ext) PLUS(0(X), 0(Y)) -> U131^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) U131^1(tt, X, Y) -> PLUS(X, Y) PLUS(plus(0(X), 0(Y)), ext) -> U131^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) The TRS R consists of the following rules: union(X, empty) -> X union(empty, X) -> X 0(z) -> z U101(tt, X, Y) -> 0(mult(X, Y)) U11(tt, V1) -> U12(isBin(V1)) U111(tt, X, Y) -> plus(0(mult(X, Y)), Y) U12(tt) -> tt U121(tt, X) -> X U131(tt, X, Y) -> 0(plus(X, Y)) U141(tt, X, Y) -> 1(plus(X, Y)) U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) U161(tt, X) -> X U171(tt, A, B) -> mult(prod(A), prod(B)) U181(tt, X) -> X U191(tt, A, B) -> plus(sum(A), sum(B)) U21(tt, V1, V2) -> U22(isBag(V1), V2) U22(tt, V2) -> U23(isBag(V2)) U23(tt) -> tt U31(tt, V1) -> U32(isBin(V1)) U32(tt) -> tt U41(tt, V1) -> U42(isBin(V1)) U42(tt) -> tt U51(tt, V1, V2) -> U52(isBin(V1), V2) U52(tt, V2) -> U53(isBin(V2)) U53(tt) -> tt U61(tt, V1, V2) -> U62(isBin(V1), V2) U62(tt, V2) -> U63(isBin(V2)) U63(tt) -> tt U71(tt, V1) -> U72(isBag(V1)) U72(tt) -> tt U81(tt, V1) -> U82(isBag(V1)) U82(tt) -> tt U91(tt) -> z and(tt, X) -> X isBag(empty) -> tt isBag(singl(V1)) -> U11(isBinKind(V1), V1) isBag(union(V1, V2)) -> U21(and(isBagKind(V1), isBagKind(V2)), V1, V2) isBagKind(empty) -> tt isBagKind(singl(V1)) -> isBinKind(V1) isBagKind(union(V1, V2)) -> and(isBagKind(V1), isBagKind(V2)) isBin(z) -> tt isBin(0(V1)) -> U31(isBinKind(V1), V1) isBin(1(V1)) -> U41(isBinKind(V1), V1) isBin(mult(V1, V2)) -> U51(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(plus(V1, V2)) -> U61(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(prod(V1)) -> U71(isBagKind(V1), V1) isBin(sum(V1)) -> U81(isBagKind(V1), V1) isBinKind(z) -> tt isBinKind(0(V1)) -> isBinKind(V1) isBinKind(1(V1)) -> isBinKind(V1) isBinKind(mult(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(plus(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(prod(V1)) -> isBagKind(V1) isBinKind(sum(V1)) -> isBagKind(V1) mult(z, X) -> U91(and(isBin(X), isBinKind(X))) mult(0(X), Y) -> U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(1(X), Y) -> U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) prod(empty) -> 1(z) prod(singl(X)) -> U161(and(isBin(X), isBinKind(X)), X) prod(union(A, B)) -> U171(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) sum(empty) -> 0(z) sum(singl(X)) -> U181(and(isBin(X), isBinKind(X)), X) sum(union(A, B)) -> U191(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) mult(mult(z, X), ext) -> mult(U91(and(isBin(X), isBinKind(X))), ext) mult(mult(0(X), Y), ext) -> mult(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) mult(mult(1(X), Y), ext) -> mult(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The set E consists of the following equations: mult(x, y) == mult(y, x) plus(x, y) == plus(y, x) union(x, y) == union(y, x) mult(mult(x, y), z') == mult(x, mult(y, z')) plus(plus(x, y), z') == plus(x, plus(y, z')) union(union(x, y), z') == union(x, union(y, z')) The set E# consists of the following equations: PLUS(plus(x, y), z') == PLUS(x, plus(y, z')) PLUS(x, y) == PLUS(y, x) We have to consider all minimal (P,E#,R,E)-chains ---------------------------------------- (22) EDPPoloProof (EQUIVALENT) We use the reduction pair processor [DA_STEIN] with a polynomial ordering [POLO]. The following set of Dependency Pairs of this DP problem can be strictly oriented. U151^1(tt, X, Y) -> PLUS(X, Y) PLUS(0(X), 1(Y)) -> U141^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) PLUS(plus(0(X), 1(Y)), ext) -> U141^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) U141^1(tt, X, Y) -> PLUS(X, Y) PLUS(1(X), 1(Y)) -> U151^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) PLUS(plus(1(X), 1(Y)), ext) -> U151^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) The remaining Dependency Pairs were at least non-strictly oriented. PLUS(plus(0(X), 1(Y)), ext) -> PLUS(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) PLUS(plus(0(X), 0(Y)), ext) -> PLUS(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) PLUS(plus(1(X), 1(Y)), ext) -> PLUS(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) U151^1(tt, X, Y) -> PLUS(plus(X, Y), 1(z)) PLUS(plus(z, X), ext) -> PLUS(U121(and(isBin(X), isBinKind(X)), X), ext) PLUS(0(X), 0(Y)) -> U131^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) U131^1(tt, X, Y) -> PLUS(X, Y) PLUS(plus(0(X), 0(Y)), ext) -> U131^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) With the implicit AFS we had to orient the following set of usable rules of R non-strictly. plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) U121(tt, X) -> X U141(tt, X, Y) -> 1(plus(X, Y)) U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) U131(tt, X, Y) -> 0(plus(X, Y)) 0(z) -> z We had to orient the following equations of E# equivalently. PLUS(plus(x, y), z') == PLUS(x, plus(y, z')) PLUS(x, y) == PLUS(y, x) With the implicit AFS we had to orient the following usable equations of E equivalently. plus(plus(x, y), z') == plus(x, plus(y, z')) plus(x, y) == plus(y, x) Used ordering: POLO with Polynomial interpretation [POLO]: POL(0(x_1)) = 2*x_1 POL(1(x_1)) = 1 + 2*x_1 POL(PLUS(x_1, x_2)) = 2*x_1 + 2*x_2 POL(U11(x_1, x_2)) = 3 + 3*x_2 POL(U12(x_1)) = 3 POL(U121(x_1, x_2)) = x_2 POL(U131(x_1, x_2, x_3)) = 2*x_2 + 2*x_3 POL(U131^1(x_1, x_2, x_3)) = 2*x_2 + 2*x_3 POL(U141(x_1, x_2, x_3)) = 1 + 2*x_2 + 2*x_3 POL(U141^1(x_1, x_2, x_3)) = 1 + 2*x_2 + 2*x_3 POL(U151(x_1, x_2, x_3)) = 2 + 2*x_2 + 2*x_3 POL(U151^1(x_1, x_2, x_3)) = 2 + 2*x_2 + 2*x_3 POL(U21(x_1, x_2, x_3)) = 3 + 3*x_2 + 3*x_3 POL(U22(x_1, x_2)) = 3 + 3*x_2 POL(U23(x_1)) = 3 POL(U31(x_1, x_2)) = 3 + 3*x_2 POL(U32(x_1)) = 3 POL(U41(x_1, x_2)) = 3 + 3*x_2 POL(U42(x_1)) = 3 POL(U51(x_1, x_2, x_3)) = 3 + 3*x_2 + 3*x_3 POL(U52(x_1, x_2)) = 3 + 3*x_2 POL(U53(x_1)) = 3 POL(U61(x_1, x_2, x_3)) = 3 + 3*x_2 + 3*x_3 POL(U62(x_1, x_2)) = 3 + 3*x_2 POL(U63(x_1)) = 3 POL(U71(x_1, x_2)) = 3 + 3*x_2 POL(U72(x_1)) = 3 POL(U81(x_1, x_2)) = 3 + 3*x_2 POL(U82(x_1)) = 3 POL(and(x_1, x_2)) = 0 POL(empty) = 0 POL(isBag(x_1)) = 0 POL(isBagKind(x_1)) = 0 POL(isBin(x_1)) = 0 POL(isBinKind(x_1)) = 0 POL(mult(x_1, x_2)) = 0 POL(plus(x_1, x_2)) = x_1 + x_2 POL(prod(x_1)) = 0 POL(singl(x_1)) = 0 POL(sum(x_1)) = 0 POL(tt) = 0 POL(union(x_1, x_2)) = 0 POL(z) = 0 ---------------------------------------- (23) Obligation: The TRS P consists of the following rules: PLUS(plus(0(X), 1(Y)), ext) -> PLUS(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) PLUS(plus(0(X), 0(Y)), ext) -> PLUS(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) PLUS(plus(1(X), 1(Y)), ext) -> PLUS(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) U151^1(tt, X, Y) -> PLUS(plus(X, Y), 1(z)) PLUS(plus(z, X), ext) -> PLUS(U121(and(isBin(X), isBinKind(X)), X), ext) PLUS(0(X), 0(Y)) -> U131^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) U131^1(tt, X, Y) -> PLUS(X, Y) PLUS(plus(0(X), 0(Y)), ext) -> U131^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) The TRS R consists of the following rules: union(X, empty) -> X union(empty, X) -> X 0(z) -> z U101(tt, X, Y) -> 0(mult(X, Y)) U11(tt, V1) -> U12(isBin(V1)) U111(tt, X, Y) -> plus(0(mult(X, Y)), Y) U12(tt) -> tt U121(tt, X) -> X U131(tt, X, Y) -> 0(plus(X, Y)) U141(tt, X, Y) -> 1(plus(X, Y)) U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) U161(tt, X) -> X U171(tt, A, B) -> mult(prod(A), prod(B)) U181(tt, X) -> X U191(tt, A, B) -> plus(sum(A), sum(B)) U21(tt, V1, V2) -> U22(isBag(V1), V2) U22(tt, V2) -> U23(isBag(V2)) U23(tt) -> tt U31(tt, V1) -> U32(isBin(V1)) U32(tt) -> tt U41(tt, V1) -> U42(isBin(V1)) U42(tt) -> tt U51(tt, V1, V2) -> U52(isBin(V1), V2) U52(tt, V2) -> U53(isBin(V2)) U53(tt) -> tt U61(tt, V1, V2) -> U62(isBin(V1), V2) U62(tt, V2) -> U63(isBin(V2)) U63(tt) -> tt U71(tt, V1) -> U72(isBag(V1)) U72(tt) -> tt U81(tt, V1) -> U82(isBag(V1)) U82(tt) -> tt U91(tt) -> z and(tt, X) -> X isBag(empty) -> tt isBag(singl(V1)) -> U11(isBinKind(V1), V1) isBag(union(V1, V2)) -> U21(and(isBagKind(V1), isBagKind(V2)), V1, V2) isBagKind(empty) -> tt isBagKind(singl(V1)) -> isBinKind(V1) isBagKind(union(V1, V2)) -> and(isBagKind(V1), isBagKind(V2)) isBin(z) -> tt isBin(0(V1)) -> U31(isBinKind(V1), V1) isBin(1(V1)) -> U41(isBinKind(V1), V1) isBin(mult(V1, V2)) -> U51(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(plus(V1, V2)) -> U61(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(prod(V1)) -> U71(isBagKind(V1), V1) isBin(sum(V1)) -> U81(isBagKind(V1), V1) isBinKind(z) -> tt isBinKind(0(V1)) -> isBinKind(V1) isBinKind(1(V1)) -> isBinKind(V1) isBinKind(mult(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(plus(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(prod(V1)) -> isBagKind(V1) isBinKind(sum(V1)) -> isBagKind(V1) mult(z, X) -> U91(and(isBin(X), isBinKind(X))) mult(0(X), Y) -> U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(1(X), Y) -> U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) prod(empty) -> 1(z) prod(singl(X)) -> U161(and(isBin(X), isBinKind(X)), X) prod(union(A, B)) -> U171(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) sum(empty) -> 0(z) sum(singl(X)) -> U181(and(isBin(X), isBinKind(X)), X) sum(union(A, B)) -> U191(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) mult(mult(z, X), ext) -> mult(U91(and(isBin(X), isBinKind(X))), ext) mult(mult(0(X), Y), ext) -> mult(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) mult(mult(1(X), Y), ext) -> mult(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The set E consists of the following equations: mult(x, y) == mult(y, x) plus(x, y) == plus(y, x) union(x, y) == union(y, x) mult(mult(x, y), z') == mult(x, mult(y, z')) plus(plus(x, y), z') == plus(x, plus(y, z')) union(union(x, y), z') == union(x, union(y, z')) The set E# consists of the following equations: PLUS(plus(x, y), z') == PLUS(x, plus(y, z')) PLUS(x, y) == PLUS(y, x) We have to consider all minimal (P,E#,R,E)-chains ---------------------------------------- (24) EDependencyGraphProof (EQUIVALENT) The approximation of the Equational Dependency Graph [DA_STEIN] contains 1 SCC with 1 less node. ---------------------------------------- (25) Obligation: The TRS P consists of the following rules: PLUS(plus(0(X), 1(Y)), ext) -> PLUS(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) PLUS(plus(1(X), 1(Y)), ext) -> PLUS(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) PLUS(plus(z, X), ext) -> PLUS(U121(and(isBin(X), isBinKind(X)), X), ext) PLUS(0(X), 0(Y)) -> U131^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) U131^1(tt, X, Y) -> PLUS(X, Y) PLUS(plus(0(X), 0(Y)), ext) -> U131^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) PLUS(plus(0(X), 0(Y)), ext) -> PLUS(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The TRS R consists of the following rules: union(X, empty) -> X union(empty, X) -> X 0(z) -> z U101(tt, X, Y) -> 0(mult(X, Y)) U11(tt, V1) -> U12(isBin(V1)) U111(tt, X, Y) -> plus(0(mult(X, Y)), Y) U12(tt) -> tt U121(tt, X) -> X U131(tt, X, Y) -> 0(plus(X, Y)) U141(tt, X, Y) -> 1(plus(X, Y)) U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) U161(tt, X) -> X U171(tt, A, B) -> mult(prod(A), prod(B)) U181(tt, X) -> X U191(tt, A, B) -> plus(sum(A), sum(B)) U21(tt, V1, V2) -> U22(isBag(V1), V2) U22(tt, V2) -> U23(isBag(V2)) U23(tt) -> tt U31(tt, V1) -> U32(isBin(V1)) U32(tt) -> tt U41(tt, V1) -> U42(isBin(V1)) U42(tt) -> tt U51(tt, V1, V2) -> U52(isBin(V1), V2) U52(tt, V2) -> U53(isBin(V2)) U53(tt) -> tt U61(tt, V1, V2) -> U62(isBin(V1), V2) U62(tt, V2) -> U63(isBin(V2)) U63(tt) -> tt U71(tt, V1) -> U72(isBag(V1)) U72(tt) -> tt U81(tt, V1) -> U82(isBag(V1)) U82(tt) -> tt U91(tt) -> z and(tt, X) -> X isBag(empty) -> tt isBag(singl(V1)) -> U11(isBinKind(V1), V1) isBag(union(V1, V2)) -> U21(and(isBagKind(V1), isBagKind(V2)), V1, V2) isBagKind(empty) -> tt isBagKind(singl(V1)) -> isBinKind(V1) isBagKind(union(V1, V2)) -> and(isBagKind(V1), isBagKind(V2)) isBin(z) -> tt isBin(0(V1)) -> U31(isBinKind(V1), V1) isBin(1(V1)) -> U41(isBinKind(V1), V1) isBin(mult(V1, V2)) -> U51(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(plus(V1, V2)) -> U61(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(prod(V1)) -> U71(isBagKind(V1), V1) isBin(sum(V1)) -> U81(isBagKind(V1), V1) isBinKind(z) -> tt isBinKind(0(V1)) -> isBinKind(V1) isBinKind(1(V1)) -> isBinKind(V1) isBinKind(mult(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(plus(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(prod(V1)) -> isBagKind(V1) isBinKind(sum(V1)) -> isBagKind(V1) mult(z, X) -> U91(and(isBin(X), isBinKind(X))) mult(0(X), Y) -> U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(1(X), Y) -> U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) prod(empty) -> 1(z) prod(singl(X)) -> U161(and(isBin(X), isBinKind(X)), X) prod(union(A, B)) -> U171(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) sum(empty) -> 0(z) sum(singl(X)) -> U181(and(isBin(X), isBinKind(X)), X) sum(union(A, B)) -> U191(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) mult(mult(z, X), ext) -> mult(U91(and(isBin(X), isBinKind(X))), ext) mult(mult(0(X), Y), ext) -> mult(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) mult(mult(1(X), Y), ext) -> mult(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The set E consists of the following equations: mult(x, y) == mult(y, x) plus(x, y) == plus(y, x) union(x, y) == union(y, x) mult(mult(x, y), z') == mult(x, mult(y, z')) plus(plus(x, y), z') == plus(x, plus(y, z')) union(union(x, y), z') == union(x, union(y, z')) The set E# consists of the following equations: PLUS(plus(x, y), z') == PLUS(x, plus(y, z')) PLUS(x, y) == PLUS(y, x) We have to consider all minimal (P,E#,R,E)-chains ---------------------------------------- (26) EDPPoloProof (EQUIVALENT) We use the reduction pair processor [DA_STEIN] with a polynomial ordering [POLO]. The following set of Dependency Pairs of this DP problem can be strictly oriented. PLUS(plus(1(X), 1(Y)), ext) -> PLUS(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The remaining Dependency Pairs were at least non-strictly oriented. PLUS(plus(0(X), 1(Y)), ext) -> PLUS(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) PLUS(plus(z, X), ext) -> PLUS(U121(and(isBin(X), isBinKind(X)), X), ext) PLUS(0(X), 0(Y)) -> U131^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) U131^1(tt, X, Y) -> PLUS(X, Y) PLUS(plus(0(X), 0(Y)), ext) -> U131^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) PLUS(plus(0(X), 0(Y)), ext) -> PLUS(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) With the implicit AFS we had to orient the following set of usable rules of R non-strictly. 0(z) -> z U131(tt, X, Y) -> 0(plus(X, Y)) U141(tt, X, Y) -> 1(plus(X, Y)) U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) U121(tt, X) -> X plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) We had to orient the following equations of E# equivalently. PLUS(plus(x, y), z') == PLUS(x, plus(y, z')) PLUS(x, y) == PLUS(y, x) With the implicit AFS we had to orient the following usable equations of E equivalently. plus(plus(x, y), z') == plus(x, plus(y, z')) plus(x, y) == plus(y, x) Used ordering: POLO with Polynomial interpretation [POLO]: POL(0(x_1)) = x_1 POL(1(x_1)) = 1 + x_1 POL(PLUS(x_1, x_2)) = 2*x_1 + 2*x_2 POL(U11(x_1, x_2)) = 3 + 3*x_2 POL(U12(x_1)) = 3 POL(U121(x_1, x_2)) = x_2 POL(U131(x_1, x_2, x_3)) = x_2 + x_3 POL(U131^1(x_1, x_2, x_3)) = 2*x_2 + 2*x_3 POL(U141(x_1, x_2, x_3)) = 1 + x_2 + x_3 POL(U151(x_1, x_2, x_3)) = 1 + x_2 + x_3 POL(U21(x_1, x_2, x_3)) = 3 + 3*x_2 + 3*x_3 POL(U22(x_1, x_2)) = 3 + 3*x_2 POL(U23(x_1)) = 3 POL(U31(x_1, x_2)) = 3 + 3*x_2 POL(U32(x_1)) = 3 POL(U41(x_1, x_2)) = 3 + 3*x_2 POL(U42(x_1)) = 3 POL(U51(x_1, x_2, x_3)) = 3 + 3*x_2 + 3*x_3 POL(U52(x_1, x_2)) = 3 + 3*x_2 POL(U53(x_1)) = 3 POL(U61(x_1, x_2, x_3)) = 3 + 3*x_2 + 3*x_3 POL(U62(x_1, x_2)) = 3 + 3*x_2 POL(U63(x_1)) = 3 POL(U71(x_1, x_2)) = 3 + 3*x_2 POL(U72(x_1)) = 3 POL(U81(x_1, x_2)) = 3 + 3*x_2 POL(U82(x_1)) = 3 POL(and(x_1, x_2)) = 0 POL(empty) = 0 POL(isBag(x_1)) = 0 POL(isBagKind(x_1)) = 0 POL(isBin(x_1)) = 0 POL(isBinKind(x_1)) = 0 POL(mult(x_1, x_2)) = 0 POL(plus(x_1, x_2)) = x_1 + x_2 POL(prod(x_1)) = 0 POL(singl(x_1)) = 0 POL(sum(x_1)) = 0 POL(tt) = 0 POL(union(x_1, x_2)) = 0 POL(z) = 0 ---------------------------------------- (27) Obligation: The TRS P consists of the following rules: PLUS(plus(0(X), 1(Y)), ext) -> PLUS(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) PLUS(plus(z, X), ext) -> PLUS(U121(and(isBin(X), isBinKind(X)), X), ext) PLUS(0(X), 0(Y)) -> U131^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) U131^1(tt, X, Y) -> PLUS(X, Y) PLUS(plus(0(X), 0(Y)), ext) -> U131^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) PLUS(plus(0(X), 0(Y)), ext) -> PLUS(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The TRS R consists of the following rules: union(X, empty) -> X union(empty, X) -> X 0(z) -> z U101(tt, X, Y) -> 0(mult(X, Y)) U11(tt, V1) -> U12(isBin(V1)) U111(tt, X, Y) -> plus(0(mult(X, Y)), Y) U12(tt) -> tt U121(tt, X) -> X U131(tt, X, Y) -> 0(plus(X, Y)) U141(tt, X, Y) -> 1(plus(X, Y)) U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) U161(tt, X) -> X U171(tt, A, B) -> mult(prod(A), prod(B)) U181(tt, X) -> X U191(tt, A, B) -> plus(sum(A), sum(B)) U21(tt, V1, V2) -> U22(isBag(V1), V2) U22(tt, V2) -> U23(isBag(V2)) U23(tt) -> tt U31(tt, V1) -> U32(isBin(V1)) U32(tt) -> tt U41(tt, V1) -> U42(isBin(V1)) U42(tt) -> tt U51(tt, V1, V2) -> U52(isBin(V1), V2) U52(tt, V2) -> U53(isBin(V2)) U53(tt) -> tt U61(tt, V1, V2) -> U62(isBin(V1), V2) U62(tt, V2) -> U63(isBin(V2)) U63(tt) -> tt U71(tt, V1) -> U72(isBag(V1)) U72(tt) -> tt U81(tt, V1) -> U82(isBag(V1)) U82(tt) -> tt U91(tt) -> z and(tt, X) -> X isBag(empty) -> tt isBag(singl(V1)) -> U11(isBinKind(V1), V1) isBag(union(V1, V2)) -> U21(and(isBagKind(V1), isBagKind(V2)), V1, V2) isBagKind(empty) -> tt isBagKind(singl(V1)) -> isBinKind(V1) isBagKind(union(V1, V2)) -> and(isBagKind(V1), isBagKind(V2)) isBin(z) -> tt isBin(0(V1)) -> U31(isBinKind(V1), V1) isBin(1(V1)) -> U41(isBinKind(V1), V1) isBin(mult(V1, V2)) -> U51(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(plus(V1, V2)) -> U61(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(prod(V1)) -> U71(isBagKind(V1), V1) isBin(sum(V1)) -> U81(isBagKind(V1), V1) isBinKind(z) -> tt isBinKind(0(V1)) -> isBinKind(V1) isBinKind(1(V1)) -> isBinKind(V1) isBinKind(mult(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(plus(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(prod(V1)) -> isBagKind(V1) isBinKind(sum(V1)) -> isBagKind(V1) mult(z, X) -> U91(and(isBin(X), isBinKind(X))) mult(0(X), Y) -> U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(1(X), Y) -> U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) prod(empty) -> 1(z) prod(singl(X)) -> U161(and(isBin(X), isBinKind(X)), X) prod(union(A, B)) -> U171(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) sum(empty) -> 0(z) sum(singl(X)) -> U181(and(isBin(X), isBinKind(X)), X) sum(union(A, B)) -> U191(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) mult(mult(z, X), ext) -> mult(U91(and(isBin(X), isBinKind(X))), ext) mult(mult(0(X), Y), ext) -> mult(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) mult(mult(1(X), Y), ext) -> mult(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The set E consists of the following equations: mult(x, y) == mult(y, x) plus(x, y) == plus(y, x) union(x, y) == union(y, x) mult(mult(x, y), z') == mult(x, mult(y, z')) plus(plus(x, y), z') == plus(x, plus(y, z')) union(union(x, y), z') == union(x, union(y, z')) The set E# consists of the following equations: PLUS(plus(x, y), z') == PLUS(x, plus(y, z')) PLUS(x, y) == PLUS(y, x) We have to consider all minimal (P,E#,R,E)-chains ---------------------------------------- (28) EDPPoloProof (EQUIVALENT) We use the reduction pair processor [DA_STEIN] with a polynomial ordering [POLO]. The following set of Dependency Pairs of this DP problem can be strictly oriented. PLUS(plus(0(X), 1(Y)), ext) -> PLUS(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) PLUS(0(X), 0(Y)) -> U131^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) PLUS(plus(0(X), 0(Y)), ext) -> U131^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) PLUS(plus(0(X), 0(Y)), ext) -> PLUS(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The remaining Dependency Pairs were at least non-strictly oriented. PLUS(plus(z, X), ext) -> PLUS(U121(and(isBin(X), isBinKind(X)), X), ext) U131^1(tt, X, Y) -> PLUS(X, Y) With the implicit AFS we had to orient the following set of usable rules of R non-strictly. U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) U121(tt, X) -> X plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) U131(tt, X, Y) -> 0(plus(X, Y)) 0(z) -> z U141(tt, X, Y) -> 1(plus(X, Y)) We had to orient the following equations of E# equivalently. PLUS(plus(x, y), z') == PLUS(x, plus(y, z')) PLUS(x, y) == PLUS(y, x) With the implicit AFS we had to orient the following usable equations of E equivalently. plus(plus(x, y), z') == plus(x, plus(y, z')) plus(x, y) == plus(y, x) Used ordering: POLO with Polynomial interpretation [POLO]: POL(0(x_1)) = 1 + x_1 POL(1(x_1)) = 1 + x_1 POL(PLUS(x_1, x_2)) = 2*x_1 + 2*x_2 POL(U11(x_1, x_2)) = 0 POL(U12(x_1)) = 0 POL(U121(x_1, x_2)) = x_2 POL(U131(x_1, x_2, x_3)) = 1 + x_2 + x_3 POL(U131^1(x_1, x_2, x_3)) = 2*x_2 + 2*x_3 POL(U141(x_1, x_2, x_3)) = 1 + x_2 + x_3 POL(U151(x_1, x_2, x_3)) = 2 + x_2 + x_3 POL(U21(x_1, x_2, x_3)) = 0 POL(U22(x_1, x_2)) = 0 POL(U23(x_1)) = 0 POL(U31(x_1, x_2)) = 0 POL(U32(x_1)) = 0 POL(U41(x_1, x_2)) = 2 POL(U42(x_1)) = 0 POL(U51(x_1, x_2, x_3)) = 0 POL(U52(x_1, x_2)) = 0 POL(U53(x_1)) = 0 POL(U61(x_1, x_2, x_3)) = 0 POL(U62(x_1, x_2)) = 0 POL(U63(x_1)) = 0 POL(U71(x_1, x_2)) = 0 POL(U72(x_1)) = 0 POL(U81(x_1, x_2)) = 0 POL(U82(x_1)) = 0 POL(and(x_1, x_2)) = 0 POL(empty) = 0 POL(isBag(x_1)) = 2*x_1 POL(isBagKind(x_1)) = 0 POL(isBin(x_1)) = 2*x_1 POL(isBinKind(x_1)) = 0 POL(mult(x_1, x_2)) = x_2 POL(plus(x_1, x_2)) = x_1 + x_2 POL(prod(x_1)) = x_1 POL(singl(x_1)) = x_1 POL(sum(x_1)) = x_1 POL(tt) = 0 POL(union(x_1, x_2)) = x_1 + x_2 POL(z) = 0 ---------------------------------------- (29) Obligation: The TRS P consists of the following rules: PLUS(plus(z, X), ext) -> PLUS(U121(and(isBin(X), isBinKind(X)), X), ext) U131^1(tt, X, Y) -> PLUS(X, Y) The TRS R consists of the following rules: union(X, empty) -> X union(empty, X) -> X 0(z) -> z U101(tt, X, Y) -> 0(mult(X, Y)) U11(tt, V1) -> U12(isBin(V1)) U111(tt, X, Y) -> plus(0(mult(X, Y)), Y) U12(tt) -> tt U121(tt, X) -> X U131(tt, X, Y) -> 0(plus(X, Y)) U141(tt, X, Y) -> 1(plus(X, Y)) U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) U161(tt, X) -> X U171(tt, A, B) -> mult(prod(A), prod(B)) U181(tt, X) -> X U191(tt, A, B) -> plus(sum(A), sum(B)) U21(tt, V1, V2) -> U22(isBag(V1), V2) U22(tt, V2) -> U23(isBag(V2)) U23(tt) -> tt U31(tt, V1) -> U32(isBin(V1)) U32(tt) -> tt U41(tt, V1) -> U42(isBin(V1)) U42(tt) -> tt U51(tt, V1, V2) -> U52(isBin(V1), V2) U52(tt, V2) -> U53(isBin(V2)) U53(tt) -> tt U61(tt, V1, V2) -> U62(isBin(V1), V2) U62(tt, V2) -> U63(isBin(V2)) U63(tt) -> tt U71(tt, V1) -> U72(isBag(V1)) U72(tt) -> tt U81(tt, V1) -> U82(isBag(V1)) U82(tt) -> tt U91(tt) -> z and(tt, X) -> X isBag(empty) -> tt isBag(singl(V1)) -> U11(isBinKind(V1), V1) isBag(union(V1, V2)) -> U21(and(isBagKind(V1), isBagKind(V2)), V1, V2) isBagKind(empty) -> tt isBagKind(singl(V1)) -> isBinKind(V1) isBagKind(union(V1, V2)) -> and(isBagKind(V1), isBagKind(V2)) isBin(z) -> tt isBin(0(V1)) -> U31(isBinKind(V1), V1) isBin(1(V1)) -> U41(isBinKind(V1), V1) isBin(mult(V1, V2)) -> U51(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(plus(V1, V2)) -> U61(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(prod(V1)) -> U71(isBagKind(V1), V1) isBin(sum(V1)) -> U81(isBagKind(V1), V1) isBinKind(z) -> tt isBinKind(0(V1)) -> isBinKind(V1) isBinKind(1(V1)) -> isBinKind(V1) isBinKind(mult(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(plus(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(prod(V1)) -> isBagKind(V1) isBinKind(sum(V1)) -> isBagKind(V1) mult(z, X) -> U91(and(isBin(X), isBinKind(X))) mult(0(X), Y) -> U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(1(X), Y) -> U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) prod(empty) -> 1(z) prod(singl(X)) -> U161(and(isBin(X), isBinKind(X)), X) prod(union(A, B)) -> U171(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) sum(empty) -> 0(z) sum(singl(X)) -> U181(and(isBin(X), isBinKind(X)), X) sum(union(A, B)) -> U191(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) mult(mult(z, X), ext) -> mult(U91(and(isBin(X), isBinKind(X))), ext) mult(mult(0(X), Y), ext) -> mult(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) mult(mult(1(X), Y), ext) -> mult(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The set E consists of the following equations: mult(x, y) == mult(y, x) plus(x, y) == plus(y, x) union(x, y) == union(y, x) mult(mult(x, y), z') == mult(x, mult(y, z')) plus(plus(x, y), z') == plus(x, plus(y, z')) union(union(x, y), z') == union(x, union(y, z')) The set E# consists of the following equations: PLUS(plus(x, y), z') == PLUS(x, plus(y, z')) PLUS(x, y) == PLUS(y, x) We have to consider all minimal (P,E#,R,E)-chains ---------------------------------------- (30) EDependencyGraphProof (EQUIVALENT) The approximation of the Equational Dependency Graph [DA_STEIN] contains 1 SCC with 1 less node. ---------------------------------------- (31) Obligation: The TRS P consists of the following rules: PLUS(plus(z, X), ext) -> PLUS(U121(and(isBin(X), isBinKind(X)), X), ext) The TRS R consists of the following rules: union(X, empty) -> X union(empty, X) -> X 0(z) -> z U101(tt, X, Y) -> 0(mult(X, Y)) U11(tt, V1) -> U12(isBin(V1)) U111(tt, X, Y) -> plus(0(mult(X, Y)), Y) U12(tt) -> tt U121(tt, X) -> X U131(tt, X, Y) -> 0(plus(X, Y)) U141(tt, X, Y) -> 1(plus(X, Y)) U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) U161(tt, X) -> X U171(tt, A, B) -> mult(prod(A), prod(B)) U181(tt, X) -> X U191(tt, A, B) -> plus(sum(A), sum(B)) U21(tt, V1, V2) -> U22(isBag(V1), V2) U22(tt, V2) -> U23(isBag(V2)) U23(tt) -> tt U31(tt, V1) -> U32(isBin(V1)) U32(tt) -> tt U41(tt, V1) -> U42(isBin(V1)) U42(tt) -> tt U51(tt, V1, V2) -> U52(isBin(V1), V2) U52(tt, V2) -> U53(isBin(V2)) U53(tt) -> tt U61(tt, V1, V2) -> U62(isBin(V1), V2) U62(tt, V2) -> U63(isBin(V2)) U63(tt) -> tt U71(tt, V1) -> U72(isBag(V1)) U72(tt) -> tt U81(tt, V1) -> U82(isBag(V1)) U82(tt) -> tt U91(tt) -> z and(tt, X) -> X isBag(empty) -> tt isBag(singl(V1)) -> U11(isBinKind(V1), V1) isBag(union(V1, V2)) -> U21(and(isBagKind(V1), isBagKind(V2)), V1, V2) isBagKind(empty) -> tt isBagKind(singl(V1)) -> isBinKind(V1) isBagKind(union(V1, V2)) -> and(isBagKind(V1), isBagKind(V2)) isBin(z) -> tt isBin(0(V1)) -> U31(isBinKind(V1), V1) isBin(1(V1)) -> U41(isBinKind(V1), V1) isBin(mult(V1, V2)) -> U51(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(plus(V1, V2)) -> U61(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(prod(V1)) -> U71(isBagKind(V1), V1) isBin(sum(V1)) -> U81(isBagKind(V1), V1) isBinKind(z) -> tt isBinKind(0(V1)) -> isBinKind(V1) isBinKind(1(V1)) -> isBinKind(V1) isBinKind(mult(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(plus(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(prod(V1)) -> isBagKind(V1) isBinKind(sum(V1)) -> isBagKind(V1) mult(z, X) -> U91(and(isBin(X), isBinKind(X))) mult(0(X), Y) -> U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(1(X), Y) -> U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) prod(empty) -> 1(z) prod(singl(X)) -> U161(and(isBin(X), isBinKind(X)), X) prod(union(A, B)) -> U171(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) sum(empty) -> 0(z) sum(singl(X)) -> U181(and(isBin(X), isBinKind(X)), X) sum(union(A, B)) -> U191(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) mult(mult(z, X), ext) -> mult(U91(and(isBin(X), isBinKind(X))), ext) mult(mult(0(X), Y), ext) -> mult(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) mult(mult(1(X), Y), ext) -> mult(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The set E consists of the following equations: mult(x, y) == mult(y, x) plus(x, y) == plus(y, x) union(x, y) == union(y, x) mult(mult(x, y), z') == mult(x, mult(y, z')) plus(plus(x, y), z') == plus(x, plus(y, z')) union(union(x, y), z') == union(x, union(y, z')) The set E# consists of the following equations: PLUS(plus(x, y), z') == PLUS(x, plus(y, z')) PLUS(x, y) == PLUS(y, x) We have to consider all minimal (P,E#,R,E)-chains ---------------------------------------- (32) EDPPoloProof (EQUIVALENT) We use the reduction pair processor [DA_STEIN] with a polynomial ordering [POLO]. All Dependency Pairs of this DP problem can be strictly oriented. PLUS(plus(z, X), ext) -> PLUS(U121(and(isBin(X), isBinKind(X)), X), ext) With the implicit AFS we had to orient the following set of usable rules of R non-strictly. isBagKind(empty) -> tt isBagKind(union(V1, V2)) -> and(isBagKind(V1), isBagKind(V2)) isBagKind(singl(V1)) -> isBinKind(V1) 0(z) -> z U131(tt, X, Y) -> 0(plus(X, Y)) and(tt, X) -> X U121(tt, X) -> X isBinKind(sum(V1)) -> isBagKind(V1) isBinKind(prod(V1)) -> isBagKind(V1) isBinKind(plus(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(mult(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(0(V1)) -> isBinKind(V1) isBinKind(1(V1)) -> isBinKind(V1) isBinKind(z) -> tt U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) U141(tt, X, Y) -> 1(plus(X, Y)) plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) We had to orient the following equations of E# equivalently. PLUS(plus(x, y), z') == PLUS(x, plus(y, z')) PLUS(x, y) == PLUS(y, x) With the implicit AFS we had to orient the following usable equations of E equivalently. plus(plus(x, y), z') == plus(x, plus(y, z')) plus(x, y) == plus(y, x) Used ordering: POLO with Polynomial interpretation [POLO]: POL(0(x_1)) = 2 POL(1(x_1)) = 3 POL(PLUS(x_1, x_2)) = x_1 + x_2 POL(U11(x_1, x_2)) = 3 + 3*x_2 POL(U12(x_1)) = 3 POL(U121(x_1, x_2)) = x_2 POL(U131(x_1, x_2, x_3)) = 2 + 2*x_1 POL(U141(x_1, x_2, x_3)) = 3 + x_1 POL(U151(x_1, x_2, x_3)) = 2*x_1 POL(U21(x_1, x_2, x_3)) = 3 + 3*x_2 + 3*x_3 POL(U22(x_1, x_2)) = 3 + 3*x_2 POL(U23(x_1)) = 3 POL(U31(x_1, x_2)) = 3 + 3*x_2 POL(U32(x_1)) = 3 POL(U41(x_1, x_2)) = 3 + 3*x_2 POL(U42(x_1)) = 3 POL(U51(x_1, x_2, x_3)) = 3 + 3*x_2 + 3*x_3 POL(U52(x_1, x_2)) = 3 + 3*x_2 POL(U53(x_1)) = 3 POL(U61(x_1, x_2, x_3)) = 3 + 3*x_2 + 3*x_3 POL(U62(x_1, x_2)) = 3 + 3*x_2 POL(U63(x_1)) = 3 POL(U71(x_1, x_2)) = 3 + 3*x_2 POL(U72(x_1)) = 3 POL(U81(x_1, x_2)) = 3 + 3*x_2 POL(U82(x_1)) = 3 POL(and(x_1, x_2)) = x_2 POL(empty) = 0 POL(isBag(x_1)) = 0 POL(isBagKind(x_1)) = 1 POL(isBin(x_1)) = 0 POL(isBinKind(x_1)) = 1 POL(mult(x_1, x_2)) = 0 POL(plus(x_1, x_2)) = 3 + x_1 + x_2 POL(prod(x_1)) = 0 POL(singl(x_1)) = 0 POL(sum(x_1)) = 0 POL(tt) = 1 POL(union(x_1, x_2)) = 0 POL(z) = 0 ---------------------------------------- (33) Obligation: P is empty. The TRS R consists of the following rules: union(X, empty) -> X union(empty, X) -> X 0(z) -> z U101(tt, X, Y) -> 0(mult(X, Y)) U11(tt, V1) -> U12(isBin(V1)) U111(tt, X, Y) -> plus(0(mult(X, Y)), Y) U12(tt) -> tt U121(tt, X) -> X U131(tt, X, Y) -> 0(plus(X, Y)) U141(tt, X, Y) -> 1(plus(X, Y)) U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) U161(tt, X) -> X U171(tt, A, B) -> mult(prod(A), prod(B)) U181(tt, X) -> X U191(tt, A, B) -> plus(sum(A), sum(B)) U21(tt, V1, V2) -> U22(isBag(V1), V2) U22(tt, V2) -> U23(isBag(V2)) U23(tt) -> tt U31(tt, V1) -> U32(isBin(V1)) U32(tt) -> tt U41(tt, V1) -> U42(isBin(V1)) U42(tt) -> tt U51(tt, V1, V2) -> U52(isBin(V1), V2) U52(tt, V2) -> U53(isBin(V2)) U53(tt) -> tt U61(tt, V1, V2) -> U62(isBin(V1), V2) U62(tt, V2) -> U63(isBin(V2)) U63(tt) -> tt U71(tt, V1) -> U72(isBag(V1)) U72(tt) -> tt U81(tt, V1) -> U82(isBag(V1)) U82(tt) -> tt U91(tt) -> z and(tt, X) -> X isBag(empty) -> tt isBag(singl(V1)) -> U11(isBinKind(V1), V1) isBag(union(V1, V2)) -> U21(and(isBagKind(V1), isBagKind(V2)), V1, V2) isBagKind(empty) -> tt isBagKind(singl(V1)) -> isBinKind(V1) isBagKind(union(V1, V2)) -> and(isBagKind(V1), isBagKind(V2)) isBin(z) -> tt isBin(0(V1)) -> U31(isBinKind(V1), V1) isBin(1(V1)) -> U41(isBinKind(V1), V1) isBin(mult(V1, V2)) -> U51(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(plus(V1, V2)) -> U61(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(prod(V1)) -> U71(isBagKind(V1), V1) isBin(sum(V1)) -> U81(isBagKind(V1), V1) isBinKind(z) -> tt isBinKind(0(V1)) -> isBinKind(V1) isBinKind(1(V1)) -> isBinKind(V1) isBinKind(mult(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(plus(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(prod(V1)) -> isBagKind(V1) isBinKind(sum(V1)) -> isBagKind(V1) mult(z, X) -> U91(and(isBin(X), isBinKind(X))) mult(0(X), Y) -> U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(1(X), Y) -> U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) prod(empty) -> 1(z) prod(singl(X)) -> U161(and(isBin(X), isBinKind(X)), X) prod(union(A, B)) -> U171(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) sum(empty) -> 0(z) sum(singl(X)) -> U181(and(isBin(X), isBinKind(X)), X) sum(union(A, B)) -> U191(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) mult(mult(z, X), ext) -> mult(U91(and(isBin(X), isBinKind(X))), ext) mult(mult(0(X), Y), ext) -> mult(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) mult(mult(1(X), Y), ext) -> mult(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The set E consists of the following equations: mult(x, y) == mult(y, x) plus(x, y) == plus(y, x) union(x, y) == union(y, x) mult(mult(x, y), z') == mult(x, mult(y, z')) plus(plus(x, y), z') == plus(x, plus(y, z')) union(union(x, y), z') == union(x, union(y, z')) The set E# consists of the following equations: PLUS(plus(x, y), z') == PLUS(x, plus(y, z')) PLUS(x, y) == PLUS(y, x) We have to consider all minimal (P,E#,R,E)-chains ---------------------------------------- (34) PisEmptyProof (EQUIVALENT) The TRS P is empty. Hence, there is no (P,E#,R,E) chain. ---------------------------------------- (35) YES ---------------------------------------- (36) Obligation: The TRS P consists of the following rules: SUM(union(A, B)) -> U191^1(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) U191^1(tt, A, B) -> SUM(A) U191^1(tt, A, B) -> SUM(B) The TRS R consists of the following rules: union(X, empty) -> X union(empty, X) -> X 0(z) -> z U101(tt, X, Y) -> 0(mult(X, Y)) U11(tt, V1) -> U12(isBin(V1)) U111(tt, X, Y) -> plus(0(mult(X, Y)), Y) U12(tt) -> tt U121(tt, X) -> X U131(tt, X, Y) -> 0(plus(X, Y)) U141(tt, X, Y) -> 1(plus(X, Y)) U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) U161(tt, X) -> X U171(tt, A, B) -> mult(prod(A), prod(B)) U181(tt, X) -> X U191(tt, A, B) -> plus(sum(A), sum(B)) U21(tt, V1, V2) -> U22(isBag(V1), V2) U22(tt, V2) -> U23(isBag(V2)) U23(tt) -> tt U31(tt, V1) -> U32(isBin(V1)) U32(tt) -> tt U41(tt, V1) -> U42(isBin(V1)) U42(tt) -> tt U51(tt, V1, V2) -> U52(isBin(V1), V2) U52(tt, V2) -> U53(isBin(V2)) U53(tt) -> tt U61(tt, V1, V2) -> U62(isBin(V1), V2) U62(tt, V2) -> U63(isBin(V2)) U63(tt) -> tt U71(tt, V1) -> U72(isBag(V1)) U72(tt) -> tt U81(tt, V1) -> U82(isBag(V1)) U82(tt) -> tt U91(tt) -> z and(tt, X) -> X isBag(empty) -> tt isBag(singl(V1)) -> U11(isBinKind(V1), V1) isBag(union(V1, V2)) -> U21(and(isBagKind(V1), isBagKind(V2)), V1, V2) isBagKind(empty) -> tt isBagKind(singl(V1)) -> isBinKind(V1) isBagKind(union(V1, V2)) -> and(isBagKind(V1), isBagKind(V2)) isBin(z) -> tt isBin(0(V1)) -> U31(isBinKind(V1), V1) isBin(1(V1)) -> U41(isBinKind(V1), V1) isBin(mult(V1, V2)) -> U51(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(plus(V1, V2)) -> U61(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(prod(V1)) -> U71(isBagKind(V1), V1) isBin(sum(V1)) -> U81(isBagKind(V1), V1) isBinKind(z) -> tt isBinKind(0(V1)) -> isBinKind(V1) isBinKind(1(V1)) -> isBinKind(V1) isBinKind(mult(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(plus(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(prod(V1)) -> isBagKind(V1) isBinKind(sum(V1)) -> isBagKind(V1) mult(z, X) -> U91(and(isBin(X), isBinKind(X))) mult(0(X), Y) -> U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(1(X), Y) -> U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) prod(empty) -> 1(z) prod(singl(X)) -> U161(and(isBin(X), isBinKind(X)), X) prod(union(A, B)) -> U171(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) sum(empty) -> 0(z) sum(singl(X)) -> U181(and(isBin(X), isBinKind(X)), X) sum(union(A, B)) -> U191(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) mult(mult(z, X), ext) -> mult(U91(and(isBin(X), isBinKind(X))), ext) mult(mult(0(X), Y), ext) -> mult(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) mult(mult(1(X), Y), ext) -> mult(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The set E consists of the following equations: mult(x, y) == mult(y, x) plus(x, y) == plus(y, x) union(x, y) == union(y, x) mult(mult(x, y), z') == mult(x, mult(y, z')) plus(plus(x, y), z') == plus(x, plus(y, z')) union(union(x, y), z') == union(x, union(y, z')) The set E# consists of the following equations: MULT(x, y) == MULT(y, x) PLUS(x, y) == PLUS(y, x) UNION(x, y) == UNION(y, x) MULT(mult(x, y), z') == MULT(x, mult(y, z')) PLUS(plus(x, y), z') == PLUS(x, plus(y, z')) UNION(union(x, y), z') == UNION(x, union(y, z')) We have to consider all minimal (P,E#,R,E)-chains ---------------------------------------- (37) ESharpUsableEquationsProof (EQUIVALENT) We can delete the following equations of E# with the esharp usable equations processor[DA_STEIN]: MULT(x, y) == MULT(y, x) PLUS(x, y) == PLUS(y, x) UNION(x, y) == UNION(y, x) MULT(mult(x, y), z') == MULT(x, mult(y, z')) PLUS(plus(x, y), z') == PLUS(x, plus(y, z')) UNION(union(x, y), z') == UNION(x, union(y, z')) ---------------------------------------- (38) Obligation: The TRS P consists of the following rules: SUM(union(A, B)) -> U191^1(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) U191^1(tt, A, B) -> SUM(A) U191^1(tt, A, B) -> SUM(B) The TRS R consists of the following rules: union(X, empty) -> X union(empty, X) -> X 0(z) -> z U101(tt, X, Y) -> 0(mult(X, Y)) U11(tt, V1) -> U12(isBin(V1)) U111(tt, X, Y) -> plus(0(mult(X, Y)), Y) U12(tt) -> tt U121(tt, X) -> X U131(tt, X, Y) -> 0(plus(X, Y)) U141(tt, X, Y) -> 1(plus(X, Y)) U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) U161(tt, X) -> X U171(tt, A, B) -> mult(prod(A), prod(B)) U181(tt, X) -> X U191(tt, A, B) -> plus(sum(A), sum(B)) U21(tt, V1, V2) -> U22(isBag(V1), V2) U22(tt, V2) -> U23(isBag(V2)) U23(tt) -> tt U31(tt, V1) -> U32(isBin(V1)) U32(tt) -> tt U41(tt, V1) -> U42(isBin(V1)) U42(tt) -> tt U51(tt, V1, V2) -> U52(isBin(V1), V2) U52(tt, V2) -> U53(isBin(V2)) U53(tt) -> tt U61(tt, V1, V2) -> U62(isBin(V1), V2) U62(tt, V2) -> U63(isBin(V2)) U63(tt) -> tt U71(tt, V1) -> U72(isBag(V1)) U72(tt) -> tt U81(tt, V1) -> U82(isBag(V1)) U82(tt) -> tt U91(tt) -> z and(tt, X) -> X isBag(empty) -> tt isBag(singl(V1)) -> U11(isBinKind(V1), V1) isBag(union(V1, V2)) -> U21(and(isBagKind(V1), isBagKind(V2)), V1, V2) isBagKind(empty) -> tt isBagKind(singl(V1)) -> isBinKind(V1) isBagKind(union(V1, V2)) -> and(isBagKind(V1), isBagKind(V2)) isBin(z) -> tt isBin(0(V1)) -> U31(isBinKind(V1), V1) isBin(1(V1)) -> U41(isBinKind(V1), V1) isBin(mult(V1, V2)) -> U51(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(plus(V1, V2)) -> U61(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(prod(V1)) -> U71(isBagKind(V1), V1) isBin(sum(V1)) -> U81(isBagKind(V1), V1) isBinKind(z) -> tt isBinKind(0(V1)) -> isBinKind(V1) isBinKind(1(V1)) -> isBinKind(V1) isBinKind(mult(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(plus(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(prod(V1)) -> isBagKind(V1) isBinKind(sum(V1)) -> isBagKind(V1) mult(z, X) -> U91(and(isBin(X), isBinKind(X))) mult(0(X), Y) -> U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(1(X), Y) -> U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) prod(empty) -> 1(z) prod(singl(X)) -> U161(and(isBin(X), isBinKind(X)), X) prod(union(A, B)) -> U171(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) sum(empty) -> 0(z) sum(singl(X)) -> U181(and(isBin(X), isBinKind(X)), X) sum(union(A, B)) -> U191(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) mult(mult(z, X), ext) -> mult(U91(and(isBin(X), isBinKind(X))), ext) mult(mult(0(X), Y), ext) -> mult(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) mult(mult(1(X), Y), ext) -> mult(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The set E consists of the following equations: mult(x, y) == mult(y, x) plus(x, y) == plus(y, x) union(x, y) == union(y, x) mult(mult(x, y), z') == mult(x, mult(y, z')) plus(plus(x, y), z') == plus(x, plus(y, z')) union(union(x, y), z') == union(x, union(y, z')) E# is empty. We have to consider all minimal (P,E#,R,E)-chains ---------------------------------------- (39) EUsableRulesReductionPairsProof (EQUIVALENT) By using the usable rules and equations with reduction pair processor [DA_STEIN] with a polynomial ordering [POLO], all dependency pairs and the corresponding usable rules can be oriented non-strictly, the usable equations and the esharp equations can be oriented equivalently. All non-usable rules and equations are removed, and those dependency pairs and usable rules that have been oriented strictly or contain non-usable symbols in their left-hand side are removed as well. The following dependency pairs can be deleted: SUM(union(A, B)) -> U191^1(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) The following rules are removed from R: union(X, empty) -> X union(empty, X) -> X 0(z) -> z U101(tt, X, Y) -> 0(mult(X, Y)) U111(tt, X, Y) -> plus(0(mult(X, Y)), Y) U121(tt, X) -> X U131(tt, X, Y) -> 0(plus(X, Y)) U141(tt, X, Y) -> 1(plus(X, Y)) U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) U161(tt, X) -> X U171(tt, A, B) -> mult(prod(A), prod(B)) U181(tt, X) -> X U191(tt, A, B) -> plus(sum(A), sum(B)) U61(tt, V1, V2) -> U62(isBin(V1), V2) U62(tt, V2) -> U63(isBin(V2)) U91(tt) -> z isBag(empty) -> tt isBag(singl(V1)) -> U11(isBinKind(V1), V1) isBag(union(V1, V2)) -> U21(and(isBagKind(V1), isBagKind(V2)), V1, V2) isBagKind(empty) -> tt isBagKind(singl(V1)) -> isBinKind(V1) isBagKind(union(V1, V2)) -> and(isBagKind(V1), isBagKind(V2)) isBin(z) -> tt isBin(0(V1)) -> U31(isBinKind(V1), V1) isBin(1(V1)) -> U41(isBinKind(V1), V1) isBin(mult(V1, V2)) -> U51(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(plus(V1, V2)) -> U61(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(prod(V1)) -> U71(isBagKind(V1), V1) isBin(sum(V1)) -> U81(isBagKind(V1), V1) isBinKind(z) -> tt isBinKind(0(V1)) -> isBinKind(V1) isBinKind(1(V1)) -> isBinKind(V1) isBinKind(mult(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(plus(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(prod(V1)) -> isBagKind(V1) isBinKind(sum(V1)) -> isBagKind(V1) mult(z, X) -> U91(and(isBin(X), isBinKind(X))) mult(0(X), Y) -> U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(1(X), Y) -> U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) prod(empty) -> 1(z) prod(singl(X)) -> U161(and(isBin(X), isBinKind(X)), X) prod(union(A, B)) -> U171(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) sum(empty) -> 0(z) sum(singl(X)) -> U181(and(isBin(X), isBinKind(X)), X) sum(union(A, B)) -> U191(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) mult(mult(z, X), ext) -> mult(U91(and(isBin(X), isBinKind(X))), ext) mult(mult(0(X), Y), ext) -> mult(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) mult(mult(1(X), Y), ext) -> mult(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The following equations are removed from E: mult(x, y) == mult(y, x) plus(x, y) == plus(y, x) union(x, y) == union(y, x) mult(mult(x, y), z') == mult(x, mult(y, z')) plus(plus(x, y), z') == plus(x, plus(y, z')) union(union(x, y), z') == union(x, union(y, z')) Used ordering: POLO with Polynomial interpretation [POLO]: POL(0(x_1)) = 2 + 3*x_1 POL(1(x_1)) = 2*x_1 POL(SUM(x_1)) = 3*x_1 POL(U11(x_1, x_2)) = x_1 + 2*x_2 POL(U12(x_1)) = 2*x_1 POL(U191^1(x_1, x_2, x_3)) = x_1 + 3*x_2 + 3*x_3 POL(U21(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(U22(x_1, x_2)) = x_1 + x_2 POL(U23(x_1)) = x_1 POL(U31(x_1, x_2)) = x_1 + 2*x_2 POL(U32(x_1)) = x_1 POL(U41(x_1, x_2)) = x_1 + x_2 POL(U42(x_1)) = x_1 POL(U51(x_1, x_2, x_3)) = 2*x_1 + x_2 + x_3 POL(U52(x_1, x_2)) = x_1 + x_2 POL(U53(x_1)) = x_1 POL(U61(x_1, x_2, x_3)) = 3 + x_1 + x_2 + 2*x_3 POL(U62(x_1, x_2)) = 2 + x_1 + x_2 POL(U63(x_1)) = x_1 POL(U71(x_1, x_2)) = x_1 + x_2 POL(U72(x_1)) = x_1 POL(U81(x_1, x_2)) = x_1 + x_2 POL(U82(x_1)) = x_1 POL(and(x_1, x_2)) = x_1 + x_2 POL(empty) = 0 POL(isBag(x_1)) = x_1 POL(isBagKind(x_1)) = 2*x_1 POL(isBin(x_1)) = x_1 POL(isBinKind(x_1)) = x_1 POL(mult(x_1, x_2)) = 3*x_1 + 3*x_2 POL(plus(x_1, x_2)) = 3 + 3*x_1 + 3*x_2 POL(prod(x_1)) = 1 + 3*x_1 POL(singl(x_1)) = 1 + 3*x_1 POL(sum(x_1)) = 3*x_1 POL(tt) = 0 POL(union(x_1, x_2)) = 3*x_1 + 3*x_2 POL(z) = 0 ---------------------------------------- (40) Obligation: The TRS P consists of the following rules: U191^1(tt, A, B) -> SUM(A) U191^1(tt, A, B) -> SUM(B) The TRS R consists of the following rules: U51(tt, V1, V2) -> U52(isBin(V1), V2) U42(tt) -> tt and(tt, X) -> X U21(tt, V1, V2) -> U22(isBag(V1), V2) U82(tt) -> tt U41(tt, V1) -> U42(isBin(V1)) U11(tt, V1) -> U12(isBin(V1)) U31(tt, V1) -> U32(isBin(V1)) U72(tt) -> tt U52(tt, V2) -> U53(isBin(V2)) U23(tt) -> tt U71(tt, V1) -> U72(isBag(V1)) U22(tt, V2) -> U23(isBag(V2)) U12(tt) -> tt U32(tt) -> tt U53(tt) -> tt U81(tt, V1) -> U82(isBag(V1)) U63(tt) -> tt E is empty. E# is empty. We have to consider all minimal (P,E#,R,E)-chains ---------------------------------------- (41) EDependencyGraphProof (EQUIVALENT) The approximation of the Equational Dependency Graph [DA_STEIN] contains 0 SCCs with 2 less nodes. ---------------------------------------- (42) TRUE ---------------------------------------- (43) Obligation: The TRS P consists of the following rules: MULT(mult(z, X), ext) -> MULT(U91(and(isBin(X), isBinKind(X))), ext) MULT(mult(0(X), Y), ext) -> U101^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) U111^1(tt, X, Y) -> MULT(X, Y) MULT(0(X), Y) -> U101^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) MULT(mult(0(X), Y), ext) -> MULT(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) MULT(mult(1(X), Y), ext) -> U111^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) MULT(1(X), Y) -> U111^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) MULT(mult(1(X), Y), ext) -> MULT(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) U101^1(tt, X, Y) -> MULT(X, Y) The TRS R consists of the following rules: union(X, empty) -> X union(empty, X) -> X 0(z) -> z U101(tt, X, Y) -> 0(mult(X, Y)) U11(tt, V1) -> U12(isBin(V1)) U111(tt, X, Y) -> plus(0(mult(X, Y)), Y) U12(tt) -> tt U121(tt, X) -> X U131(tt, X, Y) -> 0(plus(X, Y)) U141(tt, X, Y) -> 1(plus(X, Y)) U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) U161(tt, X) -> X U171(tt, A, B) -> mult(prod(A), prod(B)) U181(tt, X) -> X U191(tt, A, B) -> plus(sum(A), sum(B)) U21(tt, V1, V2) -> U22(isBag(V1), V2) U22(tt, V2) -> U23(isBag(V2)) U23(tt) -> tt U31(tt, V1) -> U32(isBin(V1)) U32(tt) -> tt U41(tt, V1) -> U42(isBin(V1)) U42(tt) -> tt U51(tt, V1, V2) -> U52(isBin(V1), V2) U52(tt, V2) -> U53(isBin(V2)) U53(tt) -> tt U61(tt, V1, V2) -> U62(isBin(V1), V2) U62(tt, V2) -> U63(isBin(V2)) U63(tt) -> tt U71(tt, V1) -> U72(isBag(V1)) U72(tt) -> tt U81(tt, V1) -> U82(isBag(V1)) U82(tt) -> tt U91(tt) -> z and(tt, X) -> X isBag(empty) -> tt isBag(singl(V1)) -> U11(isBinKind(V1), V1) isBag(union(V1, V2)) -> U21(and(isBagKind(V1), isBagKind(V2)), V1, V2) isBagKind(empty) -> tt isBagKind(singl(V1)) -> isBinKind(V1) isBagKind(union(V1, V2)) -> and(isBagKind(V1), isBagKind(V2)) isBin(z) -> tt isBin(0(V1)) -> U31(isBinKind(V1), V1) isBin(1(V1)) -> U41(isBinKind(V1), V1) isBin(mult(V1, V2)) -> U51(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(plus(V1, V2)) -> U61(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(prod(V1)) -> U71(isBagKind(V1), V1) isBin(sum(V1)) -> U81(isBagKind(V1), V1) isBinKind(z) -> tt isBinKind(0(V1)) -> isBinKind(V1) isBinKind(1(V1)) -> isBinKind(V1) isBinKind(mult(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(plus(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(prod(V1)) -> isBagKind(V1) isBinKind(sum(V1)) -> isBagKind(V1) mult(z, X) -> U91(and(isBin(X), isBinKind(X))) mult(0(X), Y) -> U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(1(X), Y) -> U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) prod(empty) -> 1(z) prod(singl(X)) -> U161(and(isBin(X), isBinKind(X)), X) prod(union(A, B)) -> U171(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) sum(empty) -> 0(z) sum(singl(X)) -> U181(and(isBin(X), isBinKind(X)), X) sum(union(A, B)) -> U191(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) mult(mult(z, X), ext) -> mult(U91(and(isBin(X), isBinKind(X))), ext) mult(mult(0(X), Y), ext) -> mult(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) mult(mult(1(X), Y), ext) -> mult(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The set E consists of the following equations: mult(x, y) == mult(y, x) plus(x, y) == plus(y, x) union(x, y) == union(y, x) mult(mult(x, y), z') == mult(x, mult(y, z')) plus(plus(x, y), z') == plus(x, plus(y, z')) union(union(x, y), z') == union(x, union(y, z')) The set E# consists of the following equations: MULT(x, y) == MULT(y, x) PLUS(x, y) == PLUS(y, x) UNION(x, y) == UNION(y, x) MULT(mult(x, y), z') == MULT(x, mult(y, z')) PLUS(plus(x, y), z') == PLUS(x, plus(y, z')) UNION(union(x, y), z') == UNION(x, union(y, z')) We have to consider all minimal (P,E#,R,E)-chains ---------------------------------------- (44) ESharpUsableEquationsProof (EQUIVALENT) We can delete the following equations of E# with the esharp usable equations processor[DA_STEIN]: PLUS(x, y) == PLUS(y, x) UNION(x, y) == UNION(y, x) PLUS(plus(x, y), z') == PLUS(x, plus(y, z')) UNION(union(x, y), z') == UNION(x, union(y, z')) ---------------------------------------- (45) Obligation: The TRS P consists of the following rules: MULT(mult(z, X), ext) -> MULT(U91(and(isBin(X), isBinKind(X))), ext) MULT(mult(0(X), Y), ext) -> U101^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) U111^1(tt, X, Y) -> MULT(X, Y) MULT(0(X), Y) -> U101^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) MULT(mult(0(X), Y), ext) -> MULT(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) MULT(mult(1(X), Y), ext) -> U111^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) MULT(1(X), Y) -> U111^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) MULT(mult(1(X), Y), ext) -> MULT(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) U101^1(tt, X, Y) -> MULT(X, Y) The TRS R consists of the following rules: union(X, empty) -> X union(empty, X) -> X 0(z) -> z U101(tt, X, Y) -> 0(mult(X, Y)) U11(tt, V1) -> U12(isBin(V1)) U111(tt, X, Y) -> plus(0(mult(X, Y)), Y) U12(tt) -> tt U121(tt, X) -> X U131(tt, X, Y) -> 0(plus(X, Y)) U141(tt, X, Y) -> 1(plus(X, Y)) U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) U161(tt, X) -> X U171(tt, A, B) -> mult(prod(A), prod(B)) U181(tt, X) -> X U191(tt, A, B) -> plus(sum(A), sum(B)) U21(tt, V1, V2) -> U22(isBag(V1), V2) U22(tt, V2) -> U23(isBag(V2)) U23(tt) -> tt U31(tt, V1) -> U32(isBin(V1)) U32(tt) -> tt U41(tt, V1) -> U42(isBin(V1)) U42(tt) -> tt U51(tt, V1, V2) -> U52(isBin(V1), V2) U52(tt, V2) -> U53(isBin(V2)) U53(tt) -> tt U61(tt, V1, V2) -> U62(isBin(V1), V2) U62(tt, V2) -> U63(isBin(V2)) U63(tt) -> tt U71(tt, V1) -> U72(isBag(V1)) U72(tt) -> tt U81(tt, V1) -> U82(isBag(V1)) U82(tt) -> tt U91(tt) -> z and(tt, X) -> X isBag(empty) -> tt isBag(singl(V1)) -> U11(isBinKind(V1), V1) isBag(union(V1, V2)) -> U21(and(isBagKind(V1), isBagKind(V2)), V1, V2) isBagKind(empty) -> tt isBagKind(singl(V1)) -> isBinKind(V1) isBagKind(union(V1, V2)) -> and(isBagKind(V1), isBagKind(V2)) isBin(z) -> tt isBin(0(V1)) -> U31(isBinKind(V1), V1) isBin(1(V1)) -> U41(isBinKind(V1), V1) isBin(mult(V1, V2)) -> U51(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(plus(V1, V2)) -> U61(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(prod(V1)) -> U71(isBagKind(V1), V1) isBin(sum(V1)) -> U81(isBagKind(V1), V1) isBinKind(z) -> tt isBinKind(0(V1)) -> isBinKind(V1) isBinKind(1(V1)) -> isBinKind(V1) isBinKind(mult(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(plus(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(prod(V1)) -> isBagKind(V1) isBinKind(sum(V1)) -> isBagKind(V1) mult(z, X) -> U91(and(isBin(X), isBinKind(X))) mult(0(X), Y) -> U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(1(X), Y) -> U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) prod(empty) -> 1(z) prod(singl(X)) -> U161(and(isBin(X), isBinKind(X)), X) prod(union(A, B)) -> U171(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) sum(empty) -> 0(z) sum(singl(X)) -> U181(and(isBin(X), isBinKind(X)), X) sum(union(A, B)) -> U191(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) mult(mult(z, X), ext) -> mult(U91(and(isBin(X), isBinKind(X))), ext) mult(mult(0(X), Y), ext) -> mult(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) mult(mult(1(X), Y), ext) -> mult(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The set E consists of the following equations: mult(x, y) == mult(y, x) plus(x, y) == plus(y, x) union(x, y) == union(y, x) mult(mult(x, y), z') == mult(x, mult(y, z')) plus(plus(x, y), z') == plus(x, plus(y, z')) union(union(x, y), z') == union(x, union(y, z')) The set E# consists of the following equations: MULT(x, y) == MULT(y, x) MULT(mult(x, y), z') == MULT(x, mult(y, z')) We have to consider all minimal (P,E#,R,E)-chains ---------------------------------------- (46) EDPPoloProof (EQUIVALENT) We use the reduction pair processor [DA_STEIN] with a polynomial ordering [POLO]. The following set of Dependency Pairs of this DP problem can be strictly oriented. MULT(mult(1(X), Y), ext) -> U111^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) MULT(1(X), Y) -> U111^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) MULT(mult(1(X), Y), ext) -> MULT(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The remaining Dependency Pairs were at least non-strictly oriented. MULT(mult(z, X), ext) -> MULT(U91(and(isBin(X), isBinKind(X))), ext) MULT(mult(0(X), Y), ext) -> U101^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) U111^1(tt, X, Y) -> MULT(X, Y) MULT(0(X), Y) -> U101^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) MULT(mult(0(X), Y), ext) -> MULT(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) U101^1(tt, X, Y) -> MULT(X, Y) With the implicit AFS we had to orient the following set of usable rules of R non-strictly. isBagKind(empty) -> tt isBagKind(union(V1, V2)) -> and(isBagKind(V1), isBagKind(V2)) isBagKind(singl(V1)) -> isBinKind(V1) U11(tt, V1) -> U12(isBin(V1)) U81(tt, V1) -> U82(isBag(V1)) U72(tt) -> tt U62(tt, V2) -> U63(isBin(V2)) and(tt, X) -> X U141(tt, X, Y) -> 1(plus(X, Y)) U101(tt, X, Y) -> 0(mult(X, Y)) U111(tt, X, Y) -> plus(0(mult(X, Y)), Y) plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) U23(tt) -> tt U121(tt, X) -> X isBinKind(sum(V1)) -> isBagKind(V1) isBinKind(prod(V1)) -> isBagKind(V1) isBinKind(plus(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(mult(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(0(V1)) -> isBinKind(V1) isBinKind(1(V1)) -> isBinKind(V1) isBinKind(z) -> tt mult(mult(0(X), Y), ext) -> mult(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) mult(z, X) -> U91(and(isBin(X), isBinKind(X))) mult(mult(z, X), ext) -> mult(U91(and(isBin(X), isBinKind(X))), ext) mult(0(X), Y) -> U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(1(X), Y) -> U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(mult(1(X), Y), ext) -> mult(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) U71(tt, V1) -> U72(isBag(V1)) 0(z) -> z U63(tt) -> tt U42(tt) -> tt isBin(z) -> tt isBin(0(V1)) -> U31(isBinKind(V1), V1) isBin(1(V1)) -> U41(isBinKind(V1), V1) isBin(plus(V1, V2)) -> U61(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(sum(V1)) -> U81(isBagKind(V1), V1) isBin(prod(V1)) -> U71(isBagKind(V1), V1) isBin(mult(V1, V2)) -> U51(and(isBinKind(V1), isBinKind(V2)), V1, V2) U32(tt) -> tt U52(tt, V2) -> U53(isBin(V2)) U41(tt, V1) -> U42(isBin(V1)) U12(tt) -> tt U82(tt) -> tt isBag(empty) -> tt isBag(singl(V1)) -> U11(isBinKind(V1), V1) isBag(union(V1, V2)) -> U21(and(isBagKind(V1), isBagKind(V2)), V1, V2) U91(tt) -> z U31(tt, V1) -> U32(isBin(V1)) U21(tt, V1, V2) -> U22(isBag(V1), V2) U131(tt, X, Y) -> 0(plus(X, Y)) U61(tt, V1, V2) -> U62(isBin(V1), V2) U51(tt, V1, V2) -> U52(isBin(V1), V2) U53(tt) -> tt U22(tt, V2) -> U23(isBag(V2)) U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) We had to orient the following equations of E# equivalently. MULT(x, y) == MULT(y, x) MULT(mult(x, y), z') == MULT(x, mult(y, z')) With the implicit AFS we had to orient the following usable equations of E equivalently. plus(plus(x, y), z') == plus(x, plus(y, z')) plus(x, y) == plus(y, x) mult(x, y) == mult(y, x) mult(mult(x, y), z') == mult(x, mult(y, z')) Used ordering: POLO with Polynomial interpretation [POLO]: POL(0(x_1)) = x_1 POL(1(x_1)) = 1 + x_1 POL(MULT(x_1, x_2)) = x_1 + x_1*x_2 + x_2 POL(U101(x_1, x_2, x_3)) = x_2 + x_2*x_3 + x_3 POL(U101^1(x_1, x_2, x_3)) = x_2 + x_2*x_3 + x_3 POL(U11(x_1, x_2)) = 1 POL(U111(x_1, x_2, x_3)) = x_1*x_3 + x_2 + x_2*x_3 + x_3 POL(U111^1(x_1, x_2, x_3)) = x_2 + x_2*x_3 + x_3 POL(U12(x_1)) = 1 POL(U121(x_1, x_2)) = x_2 POL(U131(x_1, x_2, x_3)) = x_2 + x_3 POL(U141(x_1, x_2, x_3)) = 1 + x_2 + x_3 POL(U151(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(U21(x_1, x_2, x_3)) = 1 POL(U22(x_1, x_2)) = 1 POL(U23(x_1)) = x_1^2 POL(U31(x_1, x_2)) = x_1 POL(U32(x_1)) = 1 POL(U41(x_1, x_2)) = x_1 POL(U42(x_1)) = x_1^2 POL(U51(x_1, x_2, x_3)) = 1 POL(U52(x_1, x_2)) = x_1 POL(U53(x_1)) = 1 POL(U61(x_1, x_2, x_3)) = x_1 POL(U62(x_1, x_2)) = 1 POL(U63(x_1)) = 1 POL(U71(x_1, x_2)) = 1 POL(U72(x_1)) = x_1 POL(U81(x_1, x_2)) = 1 POL(U82(x_1)) = x_1^2 POL(U91(x_1)) = 0 POL(and(x_1, x_2)) = x_1*x_2 POL(empty) = 1 POL(isBag(x_1)) = 1 POL(isBagKind(x_1)) = 1 POL(isBin(x_1)) = 1 POL(isBinKind(x_1)) = 1 POL(mult(x_1, x_2)) = x_1 + x_1*x_2 + x_2 POL(plus(x_1, x_2)) = x_1 + x_2 POL(prod(x_1)) = 0 POL(singl(x_1)) = 0 POL(sum(x_1)) = 0 POL(tt) = 1 POL(union(x_1, x_2)) = 0 POL(z) = 0 ---------------------------------------- (47) Obligation: The TRS P consists of the following rules: MULT(mult(z, X), ext) -> MULT(U91(and(isBin(X), isBinKind(X))), ext) MULT(mult(0(X), Y), ext) -> U101^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) U111^1(tt, X, Y) -> MULT(X, Y) MULT(0(X), Y) -> U101^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) MULT(mult(0(X), Y), ext) -> MULT(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) U101^1(tt, X, Y) -> MULT(X, Y) The TRS R consists of the following rules: union(X, empty) -> X union(empty, X) -> X 0(z) -> z U101(tt, X, Y) -> 0(mult(X, Y)) U11(tt, V1) -> U12(isBin(V1)) U111(tt, X, Y) -> plus(0(mult(X, Y)), Y) U12(tt) -> tt U121(tt, X) -> X U131(tt, X, Y) -> 0(plus(X, Y)) U141(tt, X, Y) -> 1(plus(X, Y)) U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) U161(tt, X) -> X U171(tt, A, B) -> mult(prod(A), prod(B)) U181(tt, X) -> X U191(tt, A, B) -> plus(sum(A), sum(B)) U21(tt, V1, V2) -> U22(isBag(V1), V2) U22(tt, V2) -> U23(isBag(V2)) U23(tt) -> tt U31(tt, V1) -> U32(isBin(V1)) U32(tt) -> tt U41(tt, V1) -> U42(isBin(V1)) U42(tt) -> tt U51(tt, V1, V2) -> U52(isBin(V1), V2) U52(tt, V2) -> U53(isBin(V2)) U53(tt) -> tt U61(tt, V1, V2) -> U62(isBin(V1), V2) U62(tt, V2) -> U63(isBin(V2)) U63(tt) -> tt U71(tt, V1) -> U72(isBag(V1)) U72(tt) -> tt U81(tt, V1) -> U82(isBag(V1)) U82(tt) -> tt U91(tt) -> z and(tt, X) -> X isBag(empty) -> tt isBag(singl(V1)) -> U11(isBinKind(V1), V1) isBag(union(V1, V2)) -> U21(and(isBagKind(V1), isBagKind(V2)), V1, V2) isBagKind(empty) -> tt isBagKind(singl(V1)) -> isBinKind(V1) isBagKind(union(V1, V2)) -> and(isBagKind(V1), isBagKind(V2)) isBin(z) -> tt isBin(0(V1)) -> U31(isBinKind(V1), V1) isBin(1(V1)) -> U41(isBinKind(V1), V1) isBin(mult(V1, V2)) -> U51(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(plus(V1, V2)) -> U61(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(prod(V1)) -> U71(isBagKind(V1), V1) isBin(sum(V1)) -> U81(isBagKind(V1), V1) isBinKind(z) -> tt isBinKind(0(V1)) -> isBinKind(V1) isBinKind(1(V1)) -> isBinKind(V1) isBinKind(mult(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(plus(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(prod(V1)) -> isBagKind(V1) isBinKind(sum(V1)) -> isBagKind(V1) mult(z, X) -> U91(and(isBin(X), isBinKind(X))) mult(0(X), Y) -> U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(1(X), Y) -> U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) prod(empty) -> 1(z) prod(singl(X)) -> U161(and(isBin(X), isBinKind(X)), X) prod(union(A, B)) -> U171(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) sum(empty) -> 0(z) sum(singl(X)) -> U181(and(isBin(X), isBinKind(X)), X) sum(union(A, B)) -> U191(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) mult(mult(z, X), ext) -> mult(U91(and(isBin(X), isBinKind(X))), ext) mult(mult(0(X), Y), ext) -> mult(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) mult(mult(1(X), Y), ext) -> mult(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The set E consists of the following equations: mult(x, y) == mult(y, x) plus(x, y) == plus(y, x) union(x, y) == union(y, x) mult(mult(x, y), z') == mult(x, mult(y, z')) plus(plus(x, y), z') == plus(x, plus(y, z')) union(union(x, y), z') == union(x, union(y, z')) The set E# consists of the following equations: MULT(x, y) == MULT(y, x) MULT(mult(x, y), z') == MULT(x, mult(y, z')) We have to consider all minimal (P,E#,R,E)-chains ---------------------------------------- (48) EDependencyGraphProof (EQUIVALENT) The approximation of the Equational Dependency Graph [DA_STEIN] contains 1 SCC with 1 less node. ---------------------------------------- (49) Obligation: The TRS P consists of the following rules: MULT(mult(0(X), Y), ext) -> U101^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) MULT(mult(z, X), ext) -> MULT(U91(and(isBin(X), isBinKind(X))), ext) MULT(0(X), Y) -> U101^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) MULT(mult(0(X), Y), ext) -> MULT(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) U101^1(tt, X, Y) -> MULT(X, Y) The TRS R consists of the following rules: union(X, empty) -> X union(empty, X) -> X 0(z) -> z U101(tt, X, Y) -> 0(mult(X, Y)) U11(tt, V1) -> U12(isBin(V1)) U111(tt, X, Y) -> plus(0(mult(X, Y)), Y) U12(tt) -> tt U121(tt, X) -> X U131(tt, X, Y) -> 0(plus(X, Y)) U141(tt, X, Y) -> 1(plus(X, Y)) U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) U161(tt, X) -> X U171(tt, A, B) -> mult(prod(A), prod(B)) U181(tt, X) -> X U191(tt, A, B) -> plus(sum(A), sum(B)) U21(tt, V1, V2) -> U22(isBag(V1), V2) U22(tt, V2) -> U23(isBag(V2)) U23(tt) -> tt U31(tt, V1) -> U32(isBin(V1)) U32(tt) -> tt U41(tt, V1) -> U42(isBin(V1)) U42(tt) -> tt U51(tt, V1, V2) -> U52(isBin(V1), V2) U52(tt, V2) -> U53(isBin(V2)) U53(tt) -> tt U61(tt, V1, V2) -> U62(isBin(V1), V2) U62(tt, V2) -> U63(isBin(V2)) U63(tt) -> tt U71(tt, V1) -> U72(isBag(V1)) U72(tt) -> tt U81(tt, V1) -> U82(isBag(V1)) U82(tt) -> tt U91(tt) -> z and(tt, X) -> X isBag(empty) -> tt isBag(singl(V1)) -> U11(isBinKind(V1), V1) isBag(union(V1, V2)) -> U21(and(isBagKind(V1), isBagKind(V2)), V1, V2) isBagKind(empty) -> tt isBagKind(singl(V1)) -> isBinKind(V1) isBagKind(union(V1, V2)) -> and(isBagKind(V1), isBagKind(V2)) isBin(z) -> tt isBin(0(V1)) -> U31(isBinKind(V1), V1) isBin(1(V1)) -> U41(isBinKind(V1), V1) isBin(mult(V1, V2)) -> U51(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(plus(V1, V2)) -> U61(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(prod(V1)) -> U71(isBagKind(V1), V1) isBin(sum(V1)) -> U81(isBagKind(V1), V1) isBinKind(z) -> tt isBinKind(0(V1)) -> isBinKind(V1) isBinKind(1(V1)) -> isBinKind(V1) isBinKind(mult(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(plus(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(prod(V1)) -> isBagKind(V1) isBinKind(sum(V1)) -> isBagKind(V1) mult(z, X) -> U91(and(isBin(X), isBinKind(X))) mult(0(X), Y) -> U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(1(X), Y) -> U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) prod(empty) -> 1(z) prod(singl(X)) -> U161(and(isBin(X), isBinKind(X)), X) prod(union(A, B)) -> U171(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) sum(empty) -> 0(z) sum(singl(X)) -> U181(and(isBin(X), isBinKind(X)), X) sum(union(A, B)) -> U191(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) mult(mult(z, X), ext) -> mult(U91(and(isBin(X), isBinKind(X))), ext) mult(mult(0(X), Y), ext) -> mult(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) mult(mult(1(X), Y), ext) -> mult(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The set E consists of the following equations: mult(x, y) == mult(y, x) plus(x, y) == plus(y, x) union(x, y) == union(y, x) mult(mult(x, y), z') == mult(x, mult(y, z')) plus(plus(x, y), z') == plus(x, plus(y, z')) union(union(x, y), z') == union(x, union(y, z')) The set E# consists of the following equations: MULT(x, y) == MULT(y, x) MULT(mult(x, y), z') == MULT(x, mult(y, z')) We have to consider all minimal (P,E#,R,E)-chains ---------------------------------------- (50) EDPPoloProof (EQUIVALENT) We use the reduction pair processor [DA_STEIN] with a polynomial ordering [POLO]. The following set of Dependency Pairs of this DP problem can be strictly oriented. MULT(mult(0(X), Y), ext) -> U101^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) MULT(0(X), Y) -> U101^1(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) The remaining Dependency Pairs were at least non-strictly oriented. MULT(mult(z, X), ext) -> MULT(U91(and(isBin(X), isBinKind(X))), ext) MULT(mult(0(X), Y), ext) -> MULT(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) U101^1(tt, X, Y) -> MULT(X, Y) With the implicit AFS we had to orient the following set of usable rules of R non-strictly. isBagKind(empty) -> tt isBagKind(union(V1, V2)) -> and(isBagKind(V1), isBagKind(V2)) isBagKind(singl(V1)) -> isBinKind(V1) and(tt, X) -> X plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) U131(tt, X, Y) -> 0(plus(X, Y)) U121(tt, X) -> X U91(tt) -> z mult(mult(0(X), Y), ext) -> mult(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) mult(z, X) -> U91(and(isBin(X), isBinKind(X))) mult(mult(z, X), ext) -> mult(U91(and(isBin(X), isBinKind(X))), ext) mult(0(X), Y) -> U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(1(X), Y) -> U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(mult(1(X), Y), ext) -> mult(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) U111(tt, X, Y) -> plus(0(mult(X, Y)), Y) 0(z) -> z U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) isBinKind(sum(V1)) -> isBagKind(V1) isBinKind(prod(V1)) -> isBagKind(V1) isBinKind(plus(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(mult(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(0(V1)) -> isBinKind(V1) isBinKind(1(V1)) -> isBinKind(V1) isBinKind(z) -> tt U141(tt, X, Y) -> 1(plus(X, Y)) U101(tt, X, Y) -> 0(mult(X, Y)) We had to orient the following equations of E# equivalently. MULT(x, y) == MULT(y, x) MULT(mult(x, y), z') == MULT(x, mult(y, z')) With the implicit AFS we had to orient the following usable equations of E equivalently. plus(plus(x, y), z') == plus(x, plus(y, z')) plus(x, y) == plus(y, x) mult(x, y) == mult(y, x) mult(mult(x, y), z') == mult(x, mult(y, z')) Used ordering: POLO with Polynomial interpretation [POLO]: POL(0(x_1)) = 1 + x_1 POL(1(x_1)) = 1 + x_1 POL(MULT(x_1, x_2)) = x_1 + x_1*x_2 + x_2 POL(U101(x_1, x_2, x_3)) = 1 + x_2 + x_2*x_3 + x_3 POL(U101^1(x_1, x_2, x_3)) = x_2 + x_2*x_3 + x_3 POL(U11(x_1, x_2)) = x_2 POL(U111(x_1, x_2, x_3)) = x_1 + x_1*x_3 + x_2 + x_2*x_3 + x_3 POL(U12(x_1)) = 1 + x_1 POL(U121(x_1, x_2)) = x_2 POL(U131(x_1, x_2, x_3)) = 1 + x_2 + x_3 POL(U141(x_1, x_2, x_3)) = 1 + x_2 + x_3 POL(U151(x_1, x_2, x_3)) = 1 + x_1 + x_2 + x_3 POL(U21(x_1, x_2, x_3)) = 1 + x_2 + x_2*x_3 + x_3 POL(U22(x_1, x_2)) = x_1*x_2 + x_2 POL(U23(x_1)) = 1 POL(U31(x_1, x_2)) = 1 + x_2 POL(U32(x_1)) = 1 POL(U41(x_1, x_2)) = x_2 POL(U42(x_1)) = 1 + x_1 POL(U51(x_1, x_2, x_3)) = 1 + x_2 + x_2*x_3 + x_3 POL(U52(x_1, x_2)) = x_2 POL(U53(x_1)) = 1 + x_1 POL(U61(x_1, x_2, x_3)) = 1 + x_2 + x_2*x_3 + x_3 POL(U62(x_1, x_2)) = x_1*x_2 + x_2 POL(U63(x_1)) = 1 POL(U71(x_1, x_2)) = 1 + x_2 POL(U72(x_1)) = 1 POL(U81(x_1, x_2)) = 1 + x_2 POL(U82(x_1)) = 1 POL(U91(x_1)) = 0 POL(and(x_1, x_2)) = x_2 POL(empty) = 1 POL(isBag(x_1)) = 0 POL(isBagKind(x_1)) = 1 POL(isBin(x_1)) = 0 POL(isBinKind(x_1)) = 1 POL(mult(x_1, x_2)) = x_1 + x_1*x_2 + x_2 POL(plus(x_1, x_2)) = x_1 + x_2 POL(prod(x_1)) = 0 POL(singl(x_1)) = 0 POL(sum(x_1)) = 0 POL(tt) = 1 POL(union(x_1, x_2)) = 0 POL(z) = 0 ---------------------------------------- (51) Obligation: The TRS P consists of the following rules: MULT(mult(z, X), ext) -> MULT(U91(and(isBin(X), isBinKind(X))), ext) MULT(mult(0(X), Y), ext) -> MULT(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) U101^1(tt, X, Y) -> MULT(X, Y) The TRS R consists of the following rules: union(X, empty) -> X union(empty, X) -> X 0(z) -> z U101(tt, X, Y) -> 0(mult(X, Y)) U11(tt, V1) -> U12(isBin(V1)) U111(tt, X, Y) -> plus(0(mult(X, Y)), Y) U12(tt) -> tt U121(tt, X) -> X U131(tt, X, Y) -> 0(plus(X, Y)) U141(tt, X, Y) -> 1(plus(X, Y)) U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) U161(tt, X) -> X U171(tt, A, B) -> mult(prod(A), prod(B)) U181(tt, X) -> X U191(tt, A, B) -> plus(sum(A), sum(B)) U21(tt, V1, V2) -> U22(isBag(V1), V2) U22(tt, V2) -> U23(isBag(V2)) U23(tt) -> tt U31(tt, V1) -> U32(isBin(V1)) U32(tt) -> tt U41(tt, V1) -> U42(isBin(V1)) U42(tt) -> tt U51(tt, V1, V2) -> U52(isBin(V1), V2) U52(tt, V2) -> U53(isBin(V2)) U53(tt) -> tt U61(tt, V1, V2) -> U62(isBin(V1), V2) U62(tt, V2) -> U63(isBin(V2)) U63(tt) -> tt U71(tt, V1) -> U72(isBag(V1)) U72(tt) -> tt U81(tt, V1) -> U82(isBag(V1)) U82(tt) -> tt U91(tt) -> z and(tt, X) -> X isBag(empty) -> tt isBag(singl(V1)) -> U11(isBinKind(V1), V1) isBag(union(V1, V2)) -> U21(and(isBagKind(V1), isBagKind(V2)), V1, V2) isBagKind(empty) -> tt isBagKind(singl(V1)) -> isBinKind(V1) isBagKind(union(V1, V2)) -> and(isBagKind(V1), isBagKind(V2)) isBin(z) -> tt isBin(0(V1)) -> U31(isBinKind(V1), V1) isBin(1(V1)) -> U41(isBinKind(V1), V1) isBin(mult(V1, V2)) -> U51(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(plus(V1, V2)) -> U61(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(prod(V1)) -> U71(isBagKind(V1), V1) isBin(sum(V1)) -> U81(isBagKind(V1), V1) isBinKind(z) -> tt isBinKind(0(V1)) -> isBinKind(V1) isBinKind(1(V1)) -> isBinKind(V1) isBinKind(mult(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(plus(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(prod(V1)) -> isBagKind(V1) isBinKind(sum(V1)) -> isBagKind(V1) mult(z, X) -> U91(and(isBin(X), isBinKind(X))) mult(0(X), Y) -> U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(1(X), Y) -> U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) prod(empty) -> 1(z) prod(singl(X)) -> U161(and(isBin(X), isBinKind(X)), X) prod(union(A, B)) -> U171(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) sum(empty) -> 0(z) sum(singl(X)) -> U181(and(isBin(X), isBinKind(X)), X) sum(union(A, B)) -> U191(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) mult(mult(z, X), ext) -> mult(U91(and(isBin(X), isBinKind(X))), ext) mult(mult(0(X), Y), ext) -> mult(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) mult(mult(1(X), Y), ext) -> mult(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The set E consists of the following equations: mult(x, y) == mult(y, x) plus(x, y) == plus(y, x) union(x, y) == union(y, x) mult(mult(x, y), z') == mult(x, mult(y, z')) plus(plus(x, y), z') == plus(x, plus(y, z')) union(union(x, y), z') == union(x, union(y, z')) The set E# consists of the following equations: MULT(x, y) == MULT(y, x) MULT(mult(x, y), z') == MULT(x, mult(y, z')) We have to consider all minimal (P,E#,R,E)-chains ---------------------------------------- (52) EDependencyGraphProof (EQUIVALENT) The approximation of the Equational Dependency Graph [DA_STEIN] contains 1 SCC with 1 less node. ---------------------------------------- (53) Obligation: The TRS P consists of the following rules: MULT(mult(z, X), ext) -> MULT(U91(and(isBin(X), isBinKind(X))), ext) MULT(mult(0(X), Y), ext) -> MULT(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The TRS R consists of the following rules: union(X, empty) -> X union(empty, X) -> X 0(z) -> z U101(tt, X, Y) -> 0(mult(X, Y)) U11(tt, V1) -> U12(isBin(V1)) U111(tt, X, Y) -> plus(0(mult(X, Y)), Y) U12(tt) -> tt U121(tt, X) -> X U131(tt, X, Y) -> 0(plus(X, Y)) U141(tt, X, Y) -> 1(plus(X, Y)) U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) U161(tt, X) -> X U171(tt, A, B) -> mult(prod(A), prod(B)) U181(tt, X) -> X U191(tt, A, B) -> plus(sum(A), sum(B)) U21(tt, V1, V2) -> U22(isBag(V1), V2) U22(tt, V2) -> U23(isBag(V2)) U23(tt) -> tt U31(tt, V1) -> U32(isBin(V1)) U32(tt) -> tt U41(tt, V1) -> U42(isBin(V1)) U42(tt) -> tt U51(tt, V1, V2) -> U52(isBin(V1), V2) U52(tt, V2) -> U53(isBin(V2)) U53(tt) -> tt U61(tt, V1, V2) -> U62(isBin(V1), V2) U62(tt, V2) -> U63(isBin(V2)) U63(tt) -> tt U71(tt, V1) -> U72(isBag(V1)) U72(tt) -> tt U81(tt, V1) -> U82(isBag(V1)) U82(tt) -> tt U91(tt) -> z and(tt, X) -> X isBag(empty) -> tt isBag(singl(V1)) -> U11(isBinKind(V1), V1) isBag(union(V1, V2)) -> U21(and(isBagKind(V1), isBagKind(V2)), V1, V2) isBagKind(empty) -> tt isBagKind(singl(V1)) -> isBinKind(V1) isBagKind(union(V1, V2)) -> and(isBagKind(V1), isBagKind(V2)) isBin(z) -> tt isBin(0(V1)) -> U31(isBinKind(V1), V1) isBin(1(V1)) -> U41(isBinKind(V1), V1) isBin(mult(V1, V2)) -> U51(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(plus(V1, V2)) -> U61(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(prod(V1)) -> U71(isBagKind(V1), V1) isBin(sum(V1)) -> U81(isBagKind(V1), V1) isBinKind(z) -> tt isBinKind(0(V1)) -> isBinKind(V1) isBinKind(1(V1)) -> isBinKind(V1) isBinKind(mult(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(plus(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(prod(V1)) -> isBagKind(V1) isBinKind(sum(V1)) -> isBagKind(V1) mult(z, X) -> U91(and(isBin(X), isBinKind(X))) mult(0(X), Y) -> U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(1(X), Y) -> U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) prod(empty) -> 1(z) prod(singl(X)) -> U161(and(isBin(X), isBinKind(X)), X) prod(union(A, B)) -> U171(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) sum(empty) -> 0(z) sum(singl(X)) -> U181(and(isBin(X), isBinKind(X)), X) sum(union(A, B)) -> U191(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) mult(mult(z, X), ext) -> mult(U91(and(isBin(X), isBinKind(X))), ext) mult(mult(0(X), Y), ext) -> mult(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) mult(mult(1(X), Y), ext) -> mult(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The set E consists of the following equations: mult(x, y) == mult(y, x) plus(x, y) == plus(y, x) union(x, y) == union(y, x) mult(mult(x, y), z') == mult(x, mult(y, z')) plus(plus(x, y), z') == plus(x, plus(y, z')) union(union(x, y), z') == union(x, union(y, z')) The set E# consists of the following equations: MULT(x, y) == MULT(y, x) MULT(mult(x, y), z') == MULT(x, mult(y, z')) We have to consider all minimal (P,E#,R,E)-chains ---------------------------------------- (54) EDPPoloProof (EQUIVALENT) We use the reduction pair processor [DA_STEIN] with a polynomial ordering [POLO]. The following set of Dependency Pairs of this DP problem can be strictly oriented. MULT(mult(z, X), ext) -> MULT(U91(and(isBin(X), isBinKind(X))), ext) The remaining Dependency Pairs were at least non-strictly oriented. MULT(mult(0(X), Y), ext) -> MULT(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) With the implicit AFS we had to orient the following set of usable rules of R non-strictly. U121(tt, X) -> X U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) 0(z) -> z U111(tt, X, Y) -> plus(0(mult(X, Y)), Y) mult(mult(0(X), Y), ext) -> mult(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) mult(z, X) -> U91(and(isBin(X), isBinKind(X))) mult(mult(z, X), ext) -> mult(U91(and(isBin(X), isBinKind(X))), ext) mult(0(X), Y) -> U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(1(X), Y) -> U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(mult(1(X), Y), ext) -> mult(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) U91(tt) -> z U131(tt, X, Y) -> 0(plus(X, Y)) U141(tt, X, Y) -> 1(plus(X, Y)) U101(tt, X, Y) -> 0(mult(X, Y)) We had to orient the following equations of E# equivalently. MULT(x, y) == MULT(y, x) MULT(mult(x, y), z') == MULT(x, mult(y, z')) With the implicit AFS we had to orient the following usable equations of E equivalently. mult(x, y) == mult(y, x) mult(mult(x, y), z') == mult(x, mult(y, z')) plus(plus(x, y), z') == plus(x, plus(y, z')) plus(x, y) == plus(y, x) Used ordering: POLO with Polynomial interpretation [POLO]: POL(0(x_1)) = 0 POL(1(x_1)) = 0 POL(MULT(x_1, x_2)) = x_1 + x_2 POL(U101(x_1, x_2, x_3)) = 2 POL(U11(x_1, x_2)) = 3 + 3*x_2 POL(U111(x_1, x_2, x_3)) = 2 + x_3 POL(U12(x_1)) = 3 POL(U121(x_1, x_2)) = 2 + x_2 POL(U131(x_1, x_2, x_3)) = 2 POL(U141(x_1, x_2, x_3)) = 2 POL(U151(x_1, x_2, x_3)) = 0 POL(U21(x_1, x_2, x_3)) = 3 + 3*x_2 + 3*x_3 POL(U22(x_1, x_2)) = 3 + 3*x_2 POL(U23(x_1)) = 3 POL(U31(x_1, x_2)) = 3 + 3*x_2 POL(U32(x_1)) = 3 POL(U41(x_1, x_2)) = 3 + 3*x_2 POL(U42(x_1)) = 3 POL(U51(x_1, x_2, x_3)) = 3 + 3*x_2 + 3*x_3 POL(U52(x_1, x_2)) = 3 + 3*x_2 POL(U53(x_1)) = 3 POL(U61(x_1, x_2, x_3)) = 3 + 3*x_2 + 3*x_3 POL(U62(x_1, x_2)) = 3 + 3*x_2 POL(U63(x_1)) = 3 POL(U71(x_1, x_2)) = 3 + 3*x_2 POL(U72(x_1)) = 3 POL(U81(x_1, x_2)) = 3 + 3*x_2 POL(U82(x_1)) = 3 POL(U91(x_1)) = 0 POL(and(x_1, x_2)) = 0 POL(empty) = 0 POL(isBag(x_1)) = 0 POL(isBagKind(x_1)) = 0 POL(isBin(x_1)) = 0 POL(isBinKind(x_1)) = 0 POL(mult(x_1, x_2)) = 2 + x_1 + x_2 POL(plus(x_1, x_2)) = 2 + x_1 + x_2 POL(prod(x_1)) = 0 POL(singl(x_1)) = 0 POL(sum(x_1)) = 0 POL(tt) = 0 POL(union(x_1, x_2)) = 0 POL(z) = 0 ---------------------------------------- (55) Obligation: The TRS P consists of the following rules: MULT(mult(0(X), Y), ext) -> MULT(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The TRS R consists of the following rules: union(X, empty) -> X union(empty, X) -> X 0(z) -> z U101(tt, X, Y) -> 0(mult(X, Y)) U11(tt, V1) -> U12(isBin(V1)) U111(tt, X, Y) -> plus(0(mult(X, Y)), Y) U12(tt) -> tt U121(tt, X) -> X U131(tt, X, Y) -> 0(plus(X, Y)) U141(tt, X, Y) -> 1(plus(X, Y)) U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) U161(tt, X) -> X U171(tt, A, B) -> mult(prod(A), prod(B)) U181(tt, X) -> X U191(tt, A, B) -> plus(sum(A), sum(B)) U21(tt, V1, V2) -> U22(isBag(V1), V2) U22(tt, V2) -> U23(isBag(V2)) U23(tt) -> tt U31(tt, V1) -> U32(isBin(V1)) U32(tt) -> tt U41(tt, V1) -> U42(isBin(V1)) U42(tt) -> tt U51(tt, V1, V2) -> U52(isBin(V1), V2) U52(tt, V2) -> U53(isBin(V2)) U53(tt) -> tt U61(tt, V1, V2) -> U62(isBin(V1), V2) U62(tt, V2) -> U63(isBin(V2)) U63(tt) -> tt U71(tt, V1) -> U72(isBag(V1)) U72(tt) -> tt U81(tt, V1) -> U82(isBag(V1)) U82(tt) -> tt U91(tt) -> z and(tt, X) -> X isBag(empty) -> tt isBag(singl(V1)) -> U11(isBinKind(V1), V1) isBag(union(V1, V2)) -> U21(and(isBagKind(V1), isBagKind(V2)), V1, V2) isBagKind(empty) -> tt isBagKind(singl(V1)) -> isBinKind(V1) isBagKind(union(V1, V2)) -> and(isBagKind(V1), isBagKind(V2)) isBin(z) -> tt isBin(0(V1)) -> U31(isBinKind(V1), V1) isBin(1(V1)) -> U41(isBinKind(V1), V1) isBin(mult(V1, V2)) -> U51(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(plus(V1, V2)) -> U61(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(prod(V1)) -> U71(isBagKind(V1), V1) isBin(sum(V1)) -> U81(isBagKind(V1), V1) isBinKind(z) -> tt isBinKind(0(V1)) -> isBinKind(V1) isBinKind(1(V1)) -> isBinKind(V1) isBinKind(mult(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(plus(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(prod(V1)) -> isBagKind(V1) isBinKind(sum(V1)) -> isBagKind(V1) mult(z, X) -> U91(and(isBin(X), isBinKind(X))) mult(0(X), Y) -> U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(1(X), Y) -> U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) prod(empty) -> 1(z) prod(singl(X)) -> U161(and(isBin(X), isBinKind(X)), X) prod(union(A, B)) -> U171(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) sum(empty) -> 0(z) sum(singl(X)) -> U181(and(isBin(X), isBinKind(X)), X) sum(union(A, B)) -> U191(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) mult(mult(z, X), ext) -> mult(U91(and(isBin(X), isBinKind(X))), ext) mult(mult(0(X), Y), ext) -> mult(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) mult(mult(1(X), Y), ext) -> mult(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The set E consists of the following equations: mult(x, y) == mult(y, x) plus(x, y) == plus(y, x) union(x, y) == union(y, x) mult(mult(x, y), z') == mult(x, mult(y, z')) plus(plus(x, y), z') == plus(x, plus(y, z')) union(union(x, y), z') == union(x, union(y, z')) The set E# consists of the following equations: MULT(x, y) == MULT(y, x) MULT(mult(x, y), z') == MULT(x, mult(y, z')) We have to consider all minimal (P,E#,R,E)-chains ---------------------------------------- (56) EDPPoloProof (EQUIVALENT) We use the reduction pair processor [DA_STEIN] with a polynomial ordering [POLO]. All Dependency Pairs of this DP problem can be strictly oriented. MULT(mult(0(X), Y), ext) -> MULT(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) With the implicit AFS we had to orient the following set of usable rules of R non-strictly. U91(tt) -> z U111(tt, X, Y) -> plus(0(mult(X, Y)), Y) U121(tt, X) -> X U101(tt, X, Y) -> 0(mult(X, Y)) plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) 0(z) -> z U131(tt, X, Y) -> 0(plus(X, Y)) mult(mult(0(X), Y), ext) -> mult(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) mult(z, X) -> U91(and(isBin(X), isBinKind(X))) mult(mult(z, X), ext) -> mult(U91(and(isBin(X), isBinKind(X))), ext) mult(0(X), Y) -> U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(1(X), Y) -> U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(mult(1(X), Y), ext) -> mult(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) U141(tt, X, Y) -> 1(plus(X, Y)) U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) We had to orient the following equations of E# equivalently. MULT(x, y) == MULT(y, x) MULT(mult(x, y), z') == MULT(x, mult(y, z')) With the implicit AFS we had to orient the following usable equations of E equivalently. plus(plus(x, y), z') == plus(x, plus(y, z')) plus(x, y) == plus(y, x) mult(x, y) == mult(y, x) mult(mult(x, y), z') == mult(x, mult(y, z')) Used ordering: POLO with Polynomial interpretation [POLO]: POL(0(x_1)) = 0 POL(1(x_1)) = 0 POL(MULT(x_1, x_2)) = 2*x_1 + 2*x_2 POL(U101(x_1, x_2, x_3)) = 0 POL(U11(x_1, x_2)) = 2 POL(U111(x_1, x_2, x_3)) = x_3 POL(U12(x_1)) = 0 POL(U121(x_1, x_2)) = x_2 POL(U131(x_1, x_2, x_3)) = 0 POL(U141(x_1, x_2, x_3)) = 0 POL(U151(x_1, x_2, x_3)) = 0 POL(U21(x_1, x_2, x_3)) = 3 + 2*x_2 POL(U22(x_1, x_2)) = 2 POL(U23(x_1)) = 0 POL(U31(x_1, x_2)) = 0 POL(U32(x_1)) = 0 POL(U41(x_1, x_2)) = 0 POL(U42(x_1)) = 0 POL(U51(x_1, x_2, x_3)) = x_1 POL(U52(x_1, x_2)) = 0 POL(U53(x_1)) = 0 POL(U61(x_1, x_2, x_3)) = 2 POL(U62(x_1, x_2)) = 2 POL(U63(x_1)) = 0 POL(U71(x_1, x_2)) = 0 POL(U72(x_1)) = 0 POL(U81(x_1, x_2)) = 1 POL(U82(x_1)) = 0 POL(U91(x_1)) = 0 POL(and(x_1, x_2)) = 2*x_2 POL(empty) = 0 POL(isBag(x_1)) = 2 + x_1 POL(isBagKind(x_1)) = 0 POL(isBin(x_1)) = 2 + 2*x_1 POL(isBinKind(x_1)) = 2 POL(mult(x_1, x_2)) = 1 + x_1 + x_2 POL(plus(x_1, x_2)) = x_1 + x_2 POL(prod(x_1)) = 2 POL(singl(x_1)) = 2 + 2*x_1 POL(sum(x_1)) = 2 + 3*x_1 POL(tt) = 0 POL(union(x_1, x_2)) = 1 + 2*x_1 + 2*x_2 POL(z) = 0 ---------------------------------------- (57) Obligation: P is empty. The TRS R consists of the following rules: union(X, empty) -> X union(empty, X) -> X 0(z) -> z U101(tt, X, Y) -> 0(mult(X, Y)) U11(tt, V1) -> U12(isBin(V1)) U111(tt, X, Y) -> plus(0(mult(X, Y)), Y) U12(tt) -> tt U121(tt, X) -> X U131(tt, X, Y) -> 0(plus(X, Y)) U141(tt, X, Y) -> 1(plus(X, Y)) U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) U161(tt, X) -> X U171(tt, A, B) -> mult(prod(A), prod(B)) U181(tt, X) -> X U191(tt, A, B) -> plus(sum(A), sum(B)) U21(tt, V1, V2) -> U22(isBag(V1), V2) U22(tt, V2) -> U23(isBag(V2)) U23(tt) -> tt U31(tt, V1) -> U32(isBin(V1)) U32(tt) -> tt U41(tt, V1) -> U42(isBin(V1)) U42(tt) -> tt U51(tt, V1, V2) -> U52(isBin(V1), V2) U52(tt, V2) -> U53(isBin(V2)) U53(tt) -> tt U61(tt, V1, V2) -> U62(isBin(V1), V2) U62(tt, V2) -> U63(isBin(V2)) U63(tt) -> tt U71(tt, V1) -> U72(isBag(V1)) U72(tt) -> tt U81(tt, V1) -> U82(isBag(V1)) U82(tt) -> tt U91(tt) -> z and(tt, X) -> X isBag(empty) -> tt isBag(singl(V1)) -> U11(isBinKind(V1), V1) isBag(union(V1, V2)) -> U21(and(isBagKind(V1), isBagKind(V2)), V1, V2) isBagKind(empty) -> tt isBagKind(singl(V1)) -> isBinKind(V1) isBagKind(union(V1, V2)) -> and(isBagKind(V1), isBagKind(V2)) isBin(z) -> tt isBin(0(V1)) -> U31(isBinKind(V1), V1) isBin(1(V1)) -> U41(isBinKind(V1), V1) isBin(mult(V1, V2)) -> U51(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(plus(V1, V2)) -> U61(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(prod(V1)) -> U71(isBagKind(V1), V1) isBin(sum(V1)) -> U81(isBagKind(V1), V1) isBinKind(z) -> tt isBinKind(0(V1)) -> isBinKind(V1) isBinKind(1(V1)) -> isBinKind(V1) isBinKind(mult(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(plus(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(prod(V1)) -> isBagKind(V1) isBinKind(sum(V1)) -> isBagKind(V1) mult(z, X) -> U91(and(isBin(X), isBinKind(X))) mult(0(X), Y) -> U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(1(X), Y) -> U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) prod(empty) -> 1(z) prod(singl(X)) -> U161(and(isBin(X), isBinKind(X)), X) prod(union(A, B)) -> U171(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) sum(empty) -> 0(z) sum(singl(X)) -> U181(and(isBin(X), isBinKind(X)), X) sum(union(A, B)) -> U191(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) mult(mult(z, X), ext) -> mult(U91(and(isBin(X), isBinKind(X))), ext) mult(mult(0(X), Y), ext) -> mult(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) mult(mult(1(X), Y), ext) -> mult(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The set E consists of the following equations: mult(x, y) == mult(y, x) plus(x, y) == plus(y, x) union(x, y) == union(y, x) mult(mult(x, y), z') == mult(x, mult(y, z')) plus(plus(x, y), z') == plus(x, plus(y, z')) union(union(x, y), z') == union(x, union(y, z')) The set E# consists of the following equations: MULT(x, y) == MULT(y, x) MULT(mult(x, y), z') == MULT(x, mult(y, z')) We have to consider all minimal (P,E#,R,E)-chains ---------------------------------------- (58) PisEmptyProof (EQUIVALENT) The TRS P is empty. Hence, there is no (P,E#,R,E) chain. ---------------------------------------- (59) YES ---------------------------------------- (60) Obligation: The TRS P consists of the following rules: PROD(union(A, B)) -> U171^1(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) U171^1(tt, A, B) -> PROD(A) U171^1(tt, A, B) -> PROD(B) The TRS R consists of the following rules: union(X, empty) -> X union(empty, X) -> X 0(z) -> z U101(tt, X, Y) -> 0(mult(X, Y)) U11(tt, V1) -> U12(isBin(V1)) U111(tt, X, Y) -> plus(0(mult(X, Y)), Y) U12(tt) -> tt U121(tt, X) -> X U131(tt, X, Y) -> 0(plus(X, Y)) U141(tt, X, Y) -> 1(plus(X, Y)) U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) U161(tt, X) -> X U171(tt, A, B) -> mult(prod(A), prod(B)) U181(tt, X) -> X U191(tt, A, B) -> plus(sum(A), sum(B)) U21(tt, V1, V2) -> U22(isBag(V1), V2) U22(tt, V2) -> U23(isBag(V2)) U23(tt) -> tt U31(tt, V1) -> U32(isBin(V1)) U32(tt) -> tt U41(tt, V1) -> U42(isBin(V1)) U42(tt) -> tt U51(tt, V1, V2) -> U52(isBin(V1), V2) U52(tt, V2) -> U53(isBin(V2)) U53(tt) -> tt U61(tt, V1, V2) -> U62(isBin(V1), V2) U62(tt, V2) -> U63(isBin(V2)) U63(tt) -> tt U71(tt, V1) -> U72(isBag(V1)) U72(tt) -> tt U81(tt, V1) -> U82(isBag(V1)) U82(tt) -> tt U91(tt) -> z and(tt, X) -> X isBag(empty) -> tt isBag(singl(V1)) -> U11(isBinKind(V1), V1) isBag(union(V1, V2)) -> U21(and(isBagKind(V1), isBagKind(V2)), V1, V2) isBagKind(empty) -> tt isBagKind(singl(V1)) -> isBinKind(V1) isBagKind(union(V1, V2)) -> and(isBagKind(V1), isBagKind(V2)) isBin(z) -> tt isBin(0(V1)) -> U31(isBinKind(V1), V1) isBin(1(V1)) -> U41(isBinKind(V1), V1) isBin(mult(V1, V2)) -> U51(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(plus(V1, V2)) -> U61(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(prod(V1)) -> U71(isBagKind(V1), V1) isBin(sum(V1)) -> U81(isBagKind(V1), V1) isBinKind(z) -> tt isBinKind(0(V1)) -> isBinKind(V1) isBinKind(1(V1)) -> isBinKind(V1) isBinKind(mult(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(plus(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(prod(V1)) -> isBagKind(V1) isBinKind(sum(V1)) -> isBagKind(V1) mult(z, X) -> U91(and(isBin(X), isBinKind(X))) mult(0(X), Y) -> U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(1(X), Y) -> U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) prod(empty) -> 1(z) prod(singl(X)) -> U161(and(isBin(X), isBinKind(X)), X) prod(union(A, B)) -> U171(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) sum(empty) -> 0(z) sum(singl(X)) -> U181(and(isBin(X), isBinKind(X)), X) sum(union(A, B)) -> U191(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) mult(mult(z, X), ext) -> mult(U91(and(isBin(X), isBinKind(X))), ext) mult(mult(0(X), Y), ext) -> mult(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) mult(mult(1(X), Y), ext) -> mult(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The set E consists of the following equations: mult(x, y) == mult(y, x) plus(x, y) == plus(y, x) union(x, y) == union(y, x) mult(mult(x, y), z') == mult(x, mult(y, z')) plus(plus(x, y), z') == plus(x, plus(y, z')) union(union(x, y), z') == union(x, union(y, z')) The set E# consists of the following equations: MULT(x, y) == MULT(y, x) PLUS(x, y) == PLUS(y, x) UNION(x, y) == UNION(y, x) MULT(mult(x, y), z') == MULT(x, mult(y, z')) PLUS(plus(x, y), z') == PLUS(x, plus(y, z')) UNION(union(x, y), z') == UNION(x, union(y, z')) We have to consider all minimal (P,E#,R,E)-chains ---------------------------------------- (61) ESharpUsableEquationsProof (EQUIVALENT) We can delete the following equations of E# with the esharp usable equations processor[DA_STEIN]: MULT(x, y) == MULT(y, x) PLUS(x, y) == PLUS(y, x) UNION(x, y) == UNION(y, x) MULT(mult(x, y), z') == MULT(x, mult(y, z')) PLUS(plus(x, y), z') == PLUS(x, plus(y, z')) UNION(union(x, y), z') == UNION(x, union(y, z')) ---------------------------------------- (62) Obligation: The TRS P consists of the following rules: PROD(union(A, B)) -> U171^1(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) U171^1(tt, A, B) -> PROD(A) U171^1(tt, A, B) -> PROD(B) The TRS R consists of the following rules: union(X, empty) -> X union(empty, X) -> X 0(z) -> z U101(tt, X, Y) -> 0(mult(X, Y)) U11(tt, V1) -> U12(isBin(V1)) U111(tt, X, Y) -> plus(0(mult(X, Y)), Y) U12(tt) -> tt U121(tt, X) -> X U131(tt, X, Y) -> 0(plus(X, Y)) U141(tt, X, Y) -> 1(plus(X, Y)) U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) U161(tt, X) -> X U171(tt, A, B) -> mult(prod(A), prod(B)) U181(tt, X) -> X U191(tt, A, B) -> plus(sum(A), sum(B)) U21(tt, V1, V2) -> U22(isBag(V1), V2) U22(tt, V2) -> U23(isBag(V2)) U23(tt) -> tt U31(tt, V1) -> U32(isBin(V1)) U32(tt) -> tt U41(tt, V1) -> U42(isBin(V1)) U42(tt) -> tt U51(tt, V1, V2) -> U52(isBin(V1), V2) U52(tt, V2) -> U53(isBin(V2)) U53(tt) -> tt U61(tt, V1, V2) -> U62(isBin(V1), V2) U62(tt, V2) -> U63(isBin(V2)) U63(tt) -> tt U71(tt, V1) -> U72(isBag(V1)) U72(tt) -> tt U81(tt, V1) -> U82(isBag(V1)) U82(tt) -> tt U91(tt) -> z and(tt, X) -> X isBag(empty) -> tt isBag(singl(V1)) -> U11(isBinKind(V1), V1) isBag(union(V1, V2)) -> U21(and(isBagKind(V1), isBagKind(V2)), V1, V2) isBagKind(empty) -> tt isBagKind(singl(V1)) -> isBinKind(V1) isBagKind(union(V1, V2)) -> and(isBagKind(V1), isBagKind(V2)) isBin(z) -> tt isBin(0(V1)) -> U31(isBinKind(V1), V1) isBin(1(V1)) -> U41(isBinKind(V1), V1) isBin(mult(V1, V2)) -> U51(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(plus(V1, V2)) -> U61(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(prod(V1)) -> U71(isBagKind(V1), V1) isBin(sum(V1)) -> U81(isBagKind(V1), V1) isBinKind(z) -> tt isBinKind(0(V1)) -> isBinKind(V1) isBinKind(1(V1)) -> isBinKind(V1) isBinKind(mult(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(plus(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(prod(V1)) -> isBagKind(V1) isBinKind(sum(V1)) -> isBagKind(V1) mult(z, X) -> U91(and(isBin(X), isBinKind(X))) mult(0(X), Y) -> U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(1(X), Y) -> U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) prod(empty) -> 1(z) prod(singl(X)) -> U161(and(isBin(X), isBinKind(X)), X) prod(union(A, B)) -> U171(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) sum(empty) -> 0(z) sum(singl(X)) -> U181(and(isBin(X), isBinKind(X)), X) sum(union(A, B)) -> U191(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) mult(mult(z, X), ext) -> mult(U91(and(isBin(X), isBinKind(X))), ext) mult(mult(0(X), Y), ext) -> mult(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) mult(mult(1(X), Y), ext) -> mult(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The set E consists of the following equations: mult(x, y) == mult(y, x) plus(x, y) == plus(y, x) union(x, y) == union(y, x) mult(mult(x, y), z') == mult(x, mult(y, z')) plus(plus(x, y), z') == plus(x, plus(y, z')) union(union(x, y), z') == union(x, union(y, z')) E# is empty. We have to consider all minimal (P,E#,R,E)-chains ---------------------------------------- (63) EUsableRulesReductionPairsProof (EQUIVALENT) By using the usable rules and equations with reduction pair processor [DA_STEIN] with a polynomial ordering [POLO], all dependency pairs and the corresponding usable rules can be oriented non-strictly, the usable equations and the esharp equations can be oriented equivalently. All non-usable rules and equations are removed, and those dependency pairs and usable rules that have been oriented strictly or contain non-usable symbols in their left-hand side are removed as well. The following dependency pairs can be deleted: PROD(union(A, B)) -> U171^1(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) The following rules are removed from R: union(X, empty) -> X union(empty, X) -> X 0(z) -> z U101(tt, X, Y) -> 0(mult(X, Y)) U111(tt, X, Y) -> plus(0(mult(X, Y)), Y) U121(tt, X) -> X U131(tt, X, Y) -> 0(plus(X, Y)) U141(tt, X, Y) -> 1(plus(X, Y)) U151(tt, X, Y) -> 0(plus(plus(X, Y), 1(z))) U161(tt, X) -> X U171(tt, A, B) -> mult(prod(A), prod(B)) U181(tt, X) -> X U191(tt, A, B) -> plus(sum(A), sum(B)) U61(tt, V1, V2) -> U62(isBin(V1), V2) U62(tt, V2) -> U63(isBin(V2)) U91(tt) -> z isBag(empty) -> tt isBag(singl(V1)) -> U11(isBinKind(V1), V1) isBag(union(V1, V2)) -> U21(and(isBagKind(V1), isBagKind(V2)), V1, V2) isBagKind(empty) -> tt isBagKind(singl(V1)) -> isBinKind(V1) isBagKind(union(V1, V2)) -> and(isBagKind(V1), isBagKind(V2)) isBin(z) -> tt isBin(0(V1)) -> U31(isBinKind(V1), V1) isBin(1(V1)) -> U41(isBinKind(V1), V1) isBin(mult(V1, V2)) -> U51(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(plus(V1, V2)) -> U61(and(isBinKind(V1), isBinKind(V2)), V1, V2) isBin(prod(V1)) -> U71(isBagKind(V1), V1) isBin(sum(V1)) -> U81(isBagKind(V1), V1) isBinKind(z) -> tt isBinKind(0(V1)) -> isBinKind(V1) isBinKind(1(V1)) -> isBinKind(V1) isBinKind(mult(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(plus(V1, V2)) -> and(isBinKind(V1), isBinKind(V2)) isBinKind(prod(V1)) -> isBagKind(V1) isBinKind(sum(V1)) -> isBagKind(V1) mult(z, X) -> U91(and(isBin(X), isBinKind(X))) mult(0(X), Y) -> U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) mult(1(X), Y) -> U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(z, X) -> U121(and(isBin(X), isBinKind(X)), X) plus(0(X), 0(Y)) -> U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(0(X), 1(Y)) -> U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) plus(1(X), 1(Y)) -> U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y) prod(empty) -> 1(z) prod(singl(X)) -> U161(and(isBin(X), isBinKind(X)), X) prod(union(A, B)) -> U171(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) sum(empty) -> 0(z) sum(singl(X)) -> U181(and(isBin(X), isBinKind(X)), X) sum(union(A, B)) -> U191(and(and(isBag(A), isBagKind(A)), and(isBag(B), isBagKind(B))), A, B) mult(mult(z, X), ext) -> mult(U91(and(isBin(X), isBinKind(X))), ext) mult(mult(0(X), Y), ext) -> mult(U101(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) mult(mult(1(X), Y), ext) -> mult(U111(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(z, X), ext) -> plus(U121(and(isBin(X), isBinKind(X)), X), ext) plus(plus(0(X), 0(Y)), ext) -> plus(U131(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(0(X), 1(Y)), ext) -> plus(U141(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) plus(plus(1(X), 1(Y)), ext) -> plus(U151(and(and(isBin(X), isBinKind(X)), and(isBin(Y), isBinKind(Y))), X, Y), ext) The following equations are removed from E: mult(x, y) == mult(y, x) plus(x, y) == plus(y, x) union(x, y) == union(y, x) mult(mult(x, y), z') == mult(x, mult(y, z')) plus(plus(x, y), z') == plus(x, plus(y, z')) union(union(x, y), z') == union(x, union(y, z')) Used ordering: POLO with Polynomial interpretation [POLO]: POL(0(x_1)) = 2 + 3*x_1 POL(1(x_1)) = 2*x_1 POL(PROD(x_1)) = 3*x_1 POL(U11(x_1, x_2)) = x_1 + 2*x_2 POL(U12(x_1)) = 2*x_1 POL(U171^1(x_1, x_2, x_3)) = x_1 + 3*x_2 + 3*x_3 POL(U21(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(U22(x_1, x_2)) = x_1 + x_2 POL(U23(x_1)) = x_1 POL(U31(x_1, x_2)) = x_1 + 2*x_2 POL(U32(x_1)) = x_1 POL(U41(x_1, x_2)) = x_1 + x_2 POL(U42(x_1)) = x_1 POL(U51(x_1, x_2, x_3)) = 2*x_1 + x_2 + x_3 POL(U52(x_1, x_2)) = x_1 + x_2 POL(U53(x_1)) = x_1 POL(U61(x_1, x_2, x_3)) = 3 + x_1 + x_2 + 2*x_3 POL(U62(x_1, x_2)) = 2 + x_1 + x_2 POL(U63(x_1)) = x_1 POL(U71(x_1, x_2)) = x_1 + x_2 POL(U72(x_1)) = x_1 POL(U81(x_1, x_2)) = x_1 + x_2 POL(U82(x_1)) = x_1 POL(and(x_1, x_2)) = x_1 + x_2 POL(empty) = 0 POL(isBag(x_1)) = x_1 POL(isBagKind(x_1)) = 2*x_1 POL(isBin(x_1)) = x_1 POL(isBinKind(x_1)) = x_1 POL(mult(x_1, x_2)) = 3*x_1 + 3*x_2 POL(plus(x_1, x_2)) = 3 + 3*x_1 + 3*x_2 POL(prod(x_1)) = 1 + 3*x_1 POL(singl(x_1)) = 1 + 3*x_1 POL(sum(x_1)) = 3*x_1 POL(tt) = 0 POL(union(x_1, x_2)) = 3*x_1 + 3*x_2 POL(z) = 0 ---------------------------------------- (64) Obligation: The TRS P consists of the following rules: U171^1(tt, A, B) -> PROD(A) U171^1(tt, A, B) -> PROD(B) The TRS R consists of the following rules: U51(tt, V1, V2) -> U52(isBin(V1), V2) U42(tt) -> tt and(tt, X) -> X U21(tt, V1, V2) -> U22(isBag(V1), V2) U82(tt) -> tt U41(tt, V1) -> U42(isBin(V1)) U11(tt, V1) -> U12(isBin(V1)) U31(tt, V1) -> U32(isBin(V1)) U72(tt) -> tt U52(tt, V2) -> U53(isBin(V2)) U23(tt) -> tt U71(tt, V1) -> U72(isBag(V1)) U22(tt, V2) -> U23(isBag(V2)) U12(tt) -> tt U32(tt) -> tt U53(tt) -> tt U81(tt, V1) -> U82(isBag(V1)) U63(tt) -> tt E is empty. E# is empty. We have to consider all minimal (P,E#,R,E)-chains ---------------------------------------- (65) EDependencyGraphProof (EQUIVALENT) The approximation of the Equational Dependency Graph [DA_STEIN] contains 0 SCCs with 2 less nodes. ---------------------------------------- (66) TRUE