6.44/2.47	YES
6.44/2.48	proof of /export/starexec/sandbox/benchmark/theBenchmark.pl
6.44/2.48	# AProVE Commit ID: 48fb2092695e11cc9f56e44b17a92a5f88ffb256 marcel 20180622 unpublished dirty
6.44/2.48	
6.44/2.48	
6.44/2.48	Left Termination of the query pattern
6.44/2.48	
6.44/2.48	parse(g,a)
6.44/2.48	
6.44/2.48	w.r.t. the given Prolog program could successfully be proven:
6.44/2.48	
6.44/2.48	(0) Prolog
6.44/2.48	(1) PrologToPiTRSProof [SOUND, 0 ms]
6.44/2.48	(2) PiTRS
6.44/2.48	(3) DependencyPairsProof [EQUIVALENT, 0 ms]
6.44/2.48	(4) PiDP
6.44/2.48	(5) DependencyGraphProof [EQUIVALENT, 4 ms]
6.44/2.48	(6) AND
6.44/2.48	    (7) PiDP
6.44/2.48	        (8) UsableRulesProof [EQUIVALENT, 0 ms]
6.44/2.48	        (9) PiDP
6.44/2.48	        (10) PiDPToQDPProof [SOUND, 0 ms]
6.44/2.48	        (11) QDP
6.44/2.48	        (12) QDPSizeChangeProof [EQUIVALENT, 0 ms]
6.44/2.48	        (13) YES
6.44/2.48	    (14) PiDP
6.44/2.48	        (15) UsableRulesProof [EQUIVALENT, 0 ms]
6.44/2.48	        (16) PiDP
6.44/2.48	        (17) PiDPToQDPProof [SOUND, 0 ms]
6.44/2.48	        (18) QDP
6.44/2.48	        (19) QDPSizeChangeProof [EQUIVALENT, 0 ms]
6.44/2.48	        (20) YES
6.44/2.48	    (21) PiDP
6.44/2.48	        (22) UsableRulesProof [EQUIVALENT, 0 ms]
6.44/2.48	        (23) PiDP
6.44/2.48	        (24) PiDPToQDPProof [SOUND, 0 ms]
6.44/2.48	        (25) QDP
6.44/2.48	        (26) MRRProof [EQUIVALENT, 12 ms]
6.44/2.48	        (27) QDP
6.44/2.48	        (28) PisEmptyProof [EQUIVALENT, 0 ms]
6.44/2.48	        (29) YES
6.44/2.48	
6.44/2.48	
6.44/2.48	----------------------------------------
6.44/2.48	
6.44/2.48	(0)
6.44/2.48	Obligation:
6.44/2.48	Clauses:
6.44/2.48	
6.44/2.48	parse(Xs, T) :- ','(app(As, .(a, .(s(A, B, C), .(b, Bs))), Xs), ','(app(As, .(s(a, s(A, B, C), b), Bs), Ys), parse(Ys, T))).
6.44/2.48	parse(Xs, T) :- ','(app(As, .(a, .(s(A, B), .(b, Bs))), Xs), ','(app(As, .(s(a, s(A, B), b), Bs), Ys), parse(Ys, T))).
6.44/2.48	parse(Xs, T) :- ','(app(As, .(a, .(b, Bs)), Xs), ','(app(As, .(s(a, b), Bs), Ys), parse(Ys, T))).
6.44/2.48	parse(.(s(A, B), []), s(A, B)).
6.44/2.48	parse(.(s(A, B, C), []), s(A, B, C)).
6.44/2.48	app([], X, X).
6.44/2.48	app(.(X, Xs), Ys, .(X, Zs)) :- app(Xs, Ys, Zs).
6.44/2.48	
6.44/2.48	
6.44/2.48	Query: parse(g,a)
6.44/2.48	----------------------------------------
6.44/2.48	
6.44/2.48	(1) PrologToPiTRSProof (SOUND)
6.44/2.48	We use the technique of [TOCL09]. With regard to the inferred argument filtering the predicates were used in the following modes:
6.44/2.48	
6.44/2.48	parse_in_2: (b,f)
6.44/2.48	
6.44/2.48	app_in_3: (f,f,b) (b,b,f)
6.44/2.48	
6.44/2.48	Transforming Prolog into the following Term Rewriting System:
6.44/2.48	
6.44/2.48	Pi-finite rewrite system:
6.44/2.48	The TRS R consists of the following rules:
6.44/2.48	
6.44/2.48	   parse_in_ga(Xs, T) -> U1_ga(Xs, T, app_in_aag(As, .(a, .(s(A, B, C), .(b, Bs))), Xs))
6.44/2.48	   app_in_aag([], X, X) -> app_out_aag([], X, X)
6.44/2.48	   app_in_aag(.(X, Xs), Ys, .(X, Zs)) -> U10_aag(X, Xs, Ys, Zs, app_in_aag(Xs, Ys, Zs))
6.44/2.48	   U10_aag(X, Xs, Ys, Zs, app_out_aag(Xs, Ys, Zs)) -> app_out_aag(.(X, Xs), Ys, .(X, Zs))
6.44/2.48	   U1_ga(Xs, T, app_out_aag(As, .(a, .(s(A, B, C), .(b, Bs))), Xs)) -> U2_ga(Xs, T, app_in_gga(As, .(s(a, s(A, B, C), b), Bs), Ys))
6.44/2.48	   app_in_gga([], X, X) -> app_out_gga([], X, X)
6.44/2.48	   app_in_gga(.(X, Xs), Ys, .(X, Zs)) -> U10_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
6.44/2.48	   U10_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) -> app_out_gga(.(X, Xs), Ys, .(X, Zs))
6.44/2.48	   U2_ga(Xs, T, app_out_gga(As, .(s(a, s(A, B, C), b), Bs), Ys)) -> U3_ga(Xs, T, parse_in_ga(Ys, T))
6.44/2.48	   parse_in_ga(Xs, T) -> U4_ga(Xs, T, app_in_aag(As, .(a, .(s(A, B), .(b, Bs))), Xs))
6.44/2.48	   U4_ga(Xs, T, app_out_aag(As, .(a, .(s(A, B), .(b, Bs))), Xs)) -> U5_ga(Xs, T, app_in_gga(As, .(s(a, s(A, B), b), Bs), Ys))
6.44/2.48	   U5_ga(Xs, T, app_out_gga(As, .(s(a, s(A, B), b), Bs), Ys)) -> U6_ga(Xs, T, parse_in_ga(Ys, T))
6.44/2.48	   parse_in_ga(Xs, T) -> U7_ga(Xs, T, app_in_aag(As, .(a, .(b, Bs)), Xs))
6.44/2.48	   U7_ga(Xs, T, app_out_aag(As, .(a, .(b, Bs)), Xs)) -> U8_ga(Xs, T, app_in_gga(As, .(s(a, b), Bs), Ys))
6.44/2.48	   U8_ga(Xs, T, app_out_gga(As, .(s(a, b), Bs), Ys)) -> U9_ga(Xs, T, parse_in_ga(Ys, T))
6.44/2.48	   parse_in_ga(.(s(A, B), []), s(A, B)) -> parse_out_ga(.(s(A, B), []), s(A, B))
6.44/2.48	   parse_in_ga(.(s(A, B, C), []), s(A, B, C)) -> parse_out_ga(.(s(A, B, C), []), s(A, B, C))
6.44/2.48	   U9_ga(Xs, T, parse_out_ga(Ys, T)) -> parse_out_ga(Xs, T)
6.44/2.48	   U6_ga(Xs, T, parse_out_ga(Ys, T)) -> parse_out_ga(Xs, T)
6.44/2.48	   U3_ga(Xs, T, parse_out_ga(Ys, T)) -> parse_out_ga(Xs, T)
6.44/2.48	
6.44/2.48	The argument filtering Pi contains the following mapping:
6.44/2.48	parse_in_ga(x1, x2)  =  parse_in_ga(x1)
6.44/2.48	
6.44/2.48	U1_ga(x1, x2, x3)  =  U1_ga(x3)
6.44/2.48	
6.44/2.48	app_in_aag(x1, x2, x3)  =  app_in_aag(x3)
6.44/2.48	
6.44/2.48	app_out_aag(x1, x2, x3)  =  app_out_aag(x1, x2)
6.44/2.48	
6.44/2.48	.(x1, x2)  =  .(x1, x2)
6.44/2.48	
6.44/2.48	U10_aag(x1, x2, x3, x4, x5)  =  U10_aag(x1, x5)
6.44/2.48	
6.44/2.48	a  =  a
6.44/2.48	
6.44/2.48	s(x1, x2, x3)  =  s(x1, x2, x3)
6.44/2.48	
6.44/2.48	b  =  b
6.44/2.48	
6.44/2.48	U2_ga(x1, x2, x3)  =  U2_ga(x3)
6.44/2.48	
6.44/2.48	app_in_gga(x1, x2, x3)  =  app_in_gga(x1, x2)
6.44/2.48	
6.44/2.48	[]  =  []
6.44/2.48	
6.44/2.48	app_out_gga(x1, x2, x3)  =  app_out_gga(x3)
6.44/2.48	
6.44/2.48	U10_gga(x1, x2, x3, x4, x5)  =  U10_gga(x1, x5)
6.44/2.48	
6.44/2.48	U3_ga(x1, x2, x3)  =  U3_ga(x3)
6.44/2.48	
6.44/2.48	U4_ga(x1, x2, x3)  =  U4_ga(x3)
6.44/2.48	
6.44/2.48	s(x1, x2)  =  s(x1, x2)
6.44/2.48	
6.44/2.48	U5_ga(x1, x2, x3)  =  U5_ga(x3)
6.44/2.48	
6.44/2.48	U6_ga(x1, x2, x3)  =  U6_ga(x3)
6.44/2.48	
6.44/2.48	U7_ga(x1, x2, x3)  =  U7_ga(x3)
6.44/2.48	
6.44/2.48	U8_ga(x1, x2, x3)  =  U8_ga(x3)
6.44/2.48	
6.44/2.48	U9_ga(x1, x2, x3)  =  U9_ga(x3)
6.44/2.48	
6.44/2.48	parse_out_ga(x1, x2)  =  parse_out_ga(x2)
6.44/2.48	
6.44/2.48	
6.44/2.48	
6.44/2.48	
6.44/2.48	
6.44/2.48	Infinitary Constructor Rewriting Termination of PiTRS implies Termination of Prolog
6.44/2.48	
6.44/2.48	
6.44/2.48	
6.44/2.48	----------------------------------------
6.44/2.48	
6.44/2.48	(2)
6.44/2.48	Obligation:
6.44/2.48	Pi-finite rewrite system:
6.44/2.48	The TRS R consists of the following rules:
6.44/2.48	
6.44/2.48	   parse_in_ga(Xs, T) -> U1_ga(Xs, T, app_in_aag(As, .(a, .(s(A, B, C), .(b, Bs))), Xs))
6.44/2.48	   app_in_aag([], X, X) -> app_out_aag([], X, X)
6.44/2.48	   app_in_aag(.(X, Xs), Ys, .(X, Zs)) -> U10_aag(X, Xs, Ys, Zs, app_in_aag(Xs, Ys, Zs))
6.44/2.48	   U10_aag(X, Xs, Ys, Zs, app_out_aag(Xs, Ys, Zs)) -> app_out_aag(.(X, Xs), Ys, .(X, Zs))
6.44/2.48	   U1_ga(Xs, T, app_out_aag(As, .(a, .(s(A, B, C), .(b, Bs))), Xs)) -> U2_ga(Xs, T, app_in_gga(As, .(s(a, s(A, B, C), b), Bs), Ys))
6.44/2.48	   app_in_gga([], X, X) -> app_out_gga([], X, X)
6.44/2.48	   app_in_gga(.(X, Xs), Ys, .(X, Zs)) -> U10_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
6.44/2.48	   U10_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) -> app_out_gga(.(X, Xs), Ys, .(X, Zs))
6.44/2.48	   U2_ga(Xs, T, app_out_gga(As, .(s(a, s(A, B, C), b), Bs), Ys)) -> U3_ga(Xs, T, parse_in_ga(Ys, T))
6.44/2.48	   parse_in_ga(Xs, T) -> U4_ga(Xs, T, app_in_aag(As, .(a, .(s(A, B), .(b, Bs))), Xs))
6.44/2.48	   U4_ga(Xs, T, app_out_aag(As, .(a, .(s(A, B), .(b, Bs))), Xs)) -> U5_ga(Xs, T, app_in_gga(As, .(s(a, s(A, B), b), Bs), Ys))
6.44/2.48	   U5_ga(Xs, T, app_out_gga(As, .(s(a, s(A, B), b), Bs), Ys)) -> U6_ga(Xs, T, parse_in_ga(Ys, T))
6.44/2.48	   parse_in_ga(Xs, T) -> U7_ga(Xs, T, app_in_aag(As, .(a, .(b, Bs)), Xs))
6.44/2.48	   U7_ga(Xs, T, app_out_aag(As, .(a, .(b, Bs)), Xs)) -> U8_ga(Xs, T, app_in_gga(As, .(s(a, b), Bs), Ys))
6.44/2.48	   U8_ga(Xs, T, app_out_gga(As, .(s(a, b), Bs), Ys)) -> U9_ga(Xs, T, parse_in_ga(Ys, T))
6.44/2.48	   parse_in_ga(.(s(A, B), []), s(A, B)) -> parse_out_ga(.(s(A, B), []), s(A, B))
6.44/2.48	   parse_in_ga(.(s(A, B, C), []), s(A, B, C)) -> parse_out_ga(.(s(A, B, C), []), s(A, B, C))
6.44/2.48	   U9_ga(Xs, T, parse_out_ga(Ys, T)) -> parse_out_ga(Xs, T)
6.44/2.48	   U6_ga(Xs, T, parse_out_ga(Ys, T)) -> parse_out_ga(Xs, T)
6.44/2.48	   U3_ga(Xs, T, parse_out_ga(Ys, T)) -> parse_out_ga(Xs, T)
6.44/2.48	
6.44/2.48	The argument filtering Pi contains the following mapping:
6.44/2.48	parse_in_ga(x1, x2)  =  parse_in_ga(x1)
6.44/2.48	
6.44/2.48	U1_ga(x1, x2, x3)  =  U1_ga(x3)
6.44/2.48	
6.44/2.48	app_in_aag(x1, x2, x3)  =  app_in_aag(x3)
6.44/2.48	
6.44/2.48	app_out_aag(x1, x2, x3)  =  app_out_aag(x1, x2)
6.44/2.48	
6.44/2.48	.(x1, x2)  =  .(x1, x2)
6.44/2.48	
6.44/2.48	U10_aag(x1, x2, x3, x4, x5)  =  U10_aag(x1, x5)
6.44/2.48	
6.44/2.48	a  =  a
6.44/2.48	
6.44/2.48	s(x1, x2, x3)  =  s(x1, x2, x3)
6.44/2.48	
6.44/2.48	b  =  b
6.44/2.48	
6.44/2.48	U2_ga(x1, x2, x3)  =  U2_ga(x3)
6.44/2.48	
6.44/2.48	app_in_gga(x1, x2, x3)  =  app_in_gga(x1, x2)
6.44/2.48	
6.44/2.48	[]  =  []
6.44/2.48	
6.44/2.48	app_out_gga(x1, x2, x3)  =  app_out_gga(x3)
6.44/2.48	
6.44/2.48	U10_gga(x1, x2, x3, x4, x5)  =  U10_gga(x1, x5)
6.44/2.48	
6.44/2.48	U3_ga(x1, x2, x3)  =  U3_ga(x3)
6.44/2.48	
6.44/2.48	U4_ga(x1, x2, x3)  =  U4_ga(x3)
6.44/2.48	
6.44/2.48	s(x1, x2)  =  s(x1, x2)
6.44/2.48	
6.44/2.48	U5_ga(x1, x2, x3)  =  U5_ga(x3)
6.44/2.48	
6.44/2.48	U6_ga(x1, x2, x3)  =  U6_ga(x3)
6.44/2.48	
6.44/2.48	U7_ga(x1, x2, x3)  =  U7_ga(x3)
6.44/2.48	
6.44/2.48	U8_ga(x1, x2, x3)  =  U8_ga(x3)
6.44/2.48	
6.44/2.48	U9_ga(x1, x2, x3)  =  U9_ga(x3)
6.44/2.48	
6.44/2.48	parse_out_ga(x1, x2)  =  parse_out_ga(x2)
6.44/2.48	
6.44/2.48	
6.44/2.48	
6.44/2.48	----------------------------------------
6.44/2.48	
6.44/2.48	(3) DependencyPairsProof (EQUIVALENT)
6.44/2.48	Using Dependency Pairs [AG00,LOPSTR] we result in the following initial DP problem:
6.44/2.48	Pi DP problem:
6.44/2.48	The TRS P consists of the following rules:
6.44/2.48	
6.44/2.48	   PARSE_IN_GA(Xs, T) -> U1_GA(Xs, T, app_in_aag(As, .(a, .(s(A, B, C), .(b, Bs))), Xs))
6.44/2.48	   PARSE_IN_GA(Xs, T) -> APP_IN_AAG(As, .(a, .(s(A, B, C), .(b, Bs))), Xs)
6.44/2.48	   APP_IN_AAG(.(X, Xs), Ys, .(X, Zs)) -> U10_AAG(X, Xs, Ys, Zs, app_in_aag(Xs, Ys, Zs))
6.44/2.48	   APP_IN_AAG(.(X, Xs), Ys, .(X, Zs)) -> APP_IN_AAG(Xs, Ys, Zs)
6.44/2.48	   U1_GA(Xs, T, app_out_aag(As, .(a, .(s(A, B, C), .(b, Bs))), Xs)) -> U2_GA(Xs, T, app_in_gga(As, .(s(a, s(A, B, C), b), Bs), Ys))
6.44/2.48	   U1_GA(Xs, T, app_out_aag(As, .(a, .(s(A, B, C), .(b, Bs))), Xs)) -> APP_IN_GGA(As, .(s(a, s(A, B, C), b), Bs), Ys)
6.44/2.48	   APP_IN_GGA(.(X, Xs), Ys, .(X, Zs)) -> U10_GGA(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
6.44/2.48	   APP_IN_GGA(.(X, Xs), Ys, .(X, Zs)) -> APP_IN_GGA(Xs, Ys, Zs)
6.44/2.48	   U2_GA(Xs, T, app_out_gga(As, .(s(a, s(A, B, C), b), Bs), Ys)) -> U3_GA(Xs, T, parse_in_ga(Ys, T))
6.44/2.48	   U2_GA(Xs, T, app_out_gga(As, .(s(a, s(A, B, C), b), Bs), Ys)) -> PARSE_IN_GA(Ys, T)
6.44/2.48	   PARSE_IN_GA(Xs, T) -> U4_GA(Xs, T, app_in_aag(As, .(a, .(s(A, B), .(b, Bs))), Xs))
6.44/2.48	   PARSE_IN_GA(Xs, T) -> APP_IN_AAG(As, .(a, .(s(A, B), .(b, Bs))), Xs)
6.44/2.48	   U4_GA(Xs, T, app_out_aag(As, .(a, .(s(A, B), .(b, Bs))), Xs)) -> U5_GA(Xs, T, app_in_gga(As, .(s(a, s(A, B), b), Bs), Ys))
6.44/2.48	   U4_GA(Xs, T, app_out_aag(As, .(a, .(s(A, B), .(b, Bs))), Xs)) -> APP_IN_GGA(As, .(s(a, s(A, B), b), Bs), Ys)
6.44/2.48	   U5_GA(Xs, T, app_out_gga(As, .(s(a, s(A, B), b), Bs), Ys)) -> U6_GA(Xs, T, parse_in_ga(Ys, T))
6.44/2.48	   U5_GA(Xs, T, app_out_gga(As, .(s(a, s(A, B), b), Bs), Ys)) -> PARSE_IN_GA(Ys, T)
6.44/2.48	   PARSE_IN_GA(Xs, T) -> U7_GA(Xs, T, app_in_aag(As, .(a, .(b, Bs)), Xs))
6.44/2.48	   PARSE_IN_GA(Xs, T) -> APP_IN_AAG(As, .(a, .(b, Bs)), Xs)
6.44/2.48	   U7_GA(Xs, T, app_out_aag(As, .(a, .(b, Bs)), Xs)) -> U8_GA(Xs, T, app_in_gga(As, .(s(a, b), Bs), Ys))
6.44/2.48	   U7_GA(Xs, T, app_out_aag(As, .(a, .(b, Bs)), Xs)) -> APP_IN_GGA(As, .(s(a, b), Bs), Ys)
6.44/2.48	   U8_GA(Xs, T, app_out_gga(As, .(s(a, b), Bs), Ys)) -> U9_GA(Xs, T, parse_in_ga(Ys, T))
6.44/2.48	   U8_GA(Xs, T, app_out_gga(As, .(s(a, b), Bs), Ys)) -> PARSE_IN_GA(Ys, T)
6.44/2.48	
6.44/2.48	The TRS R consists of the following rules:
6.44/2.48	
6.44/2.48	   parse_in_ga(Xs, T) -> U1_ga(Xs, T, app_in_aag(As, .(a, .(s(A, B, C), .(b, Bs))), Xs))
6.44/2.48	   app_in_aag([], X, X) -> app_out_aag([], X, X)
6.44/2.48	   app_in_aag(.(X, Xs), Ys, .(X, Zs)) -> U10_aag(X, Xs, Ys, Zs, app_in_aag(Xs, Ys, Zs))
6.44/2.48	   U10_aag(X, Xs, Ys, Zs, app_out_aag(Xs, Ys, Zs)) -> app_out_aag(.(X, Xs), Ys, .(X, Zs))
6.44/2.48	   U1_ga(Xs, T, app_out_aag(As, .(a, .(s(A, B, C), .(b, Bs))), Xs)) -> U2_ga(Xs, T, app_in_gga(As, .(s(a, s(A, B, C), b), Bs), Ys))
6.44/2.48	   app_in_gga([], X, X) -> app_out_gga([], X, X)
6.44/2.48	   app_in_gga(.(X, Xs), Ys, .(X, Zs)) -> U10_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
6.44/2.48	   U10_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) -> app_out_gga(.(X, Xs), Ys, .(X, Zs))
6.44/2.48	   U2_ga(Xs, T, app_out_gga(As, .(s(a, s(A, B, C), b), Bs), Ys)) -> U3_ga(Xs, T, parse_in_ga(Ys, T))
6.44/2.48	   parse_in_ga(Xs, T) -> U4_ga(Xs, T, app_in_aag(As, .(a, .(s(A, B), .(b, Bs))), Xs))
6.44/2.48	   U4_ga(Xs, T, app_out_aag(As, .(a, .(s(A, B), .(b, Bs))), Xs)) -> U5_ga(Xs, T, app_in_gga(As, .(s(a, s(A, B), b), Bs), Ys))
6.44/2.48	   U5_ga(Xs, T, app_out_gga(As, .(s(a, s(A, B), b), Bs), Ys)) -> U6_ga(Xs, T, parse_in_ga(Ys, T))
6.44/2.48	   parse_in_ga(Xs, T) -> U7_ga(Xs, T, app_in_aag(As, .(a, .(b, Bs)), Xs))
6.44/2.48	   U7_ga(Xs, T, app_out_aag(As, .(a, .(b, Bs)), Xs)) -> U8_ga(Xs, T, app_in_gga(As, .(s(a, b), Bs), Ys))
6.44/2.48	   U8_ga(Xs, T, app_out_gga(As, .(s(a, b), Bs), Ys)) -> U9_ga(Xs, T, parse_in_ga(Ys, T))
6.44/2.48	   parse_in_ga(.(s(A, B), []), s(A, B)) -> parse_out_ga(.(s(A, B), []), s(A, B))
6.44/2.48	   parse_in_ga(.(s(A, B, C), []), s(A, B, C)) -> parse_out_ga(.(s(A, B, C), []), s(A, B, C))
6.44/2.48	   U9_ga(Xs, T, parse_out_ga(Ys, T)) -> parse_out_ga(Xs, T)
6.44/2.48	   U6_ga(Xs, T, parse_out_ga(Ys, T)) -> parse_out_ga(Xs, T)
6.44/2.48	   U3_ga(Xs, T, parse_out_ga(Ys, T)) -> parse_out_ga(Xs, T)
6.44/2.48	
6.44/2.48	The argument filtering Pi contains the following mapping:
6.44/2.48	parse_in_ga(x1, x2)  =  parse_in_ga(x1)
6.44/2.48	
6.44/2.48	U1_ga(x1, x2, x3)  =  U1_ga(x3)
6.44/2.48	
6.44/2.48	app_in_aag(x1, x2, x3)  =  app_in_aag(x3)
6.44/2.48	
6.44/2.48	app_out_aag(x1, x2, x3)  =  app_out_aag(x1, x2)
6.44/2.48	
6.44/2.48	.(x1, x2)  =  .(x1, x2)
6.44/2.48	
6.44/2.48	U10_aag(x1, x2, x3, x4, x5)  =  U10_aag(x1, x5)
6.44/2.48	
6.44/2.48	a  =  a
6.44/2.48	
6.44/2.48	s(x1, x2, x3)  =  s(x1, x2, x3)
6.44/2.48	
6.44/2.48	b  =  b
6.44/2.48	
6.44/2.48	U2_ga(x1, x2, x3)  =  U2_ga(x3)
6.44/2.48	
6.44/2.48	app_in_gga(x1, x2, x3)  =  app_in_gga(x1, x2)
6.44/2.48	
6.44/2.48	[]  =  []
6.44/2.48	
6.44/2.48	app_out_gga(x1, x2, x3)  =  app_out_gga(x3)
6.44/2.48	
6.44/2.48	U10_gga(x1, x2, x3, x4, x5)  =  U10_gga(x1, x5)
6.44/2.48	
6.44/2.48	U3_ga(x1, x2, x3)  =  U3_ga(x3)
6.44/2.48	
6.44/2.48	U4_ga(x1, x2, x3)  =  U4_ga(x3)
6.44/2.48	
6.44/2.48	s(x1, x2)  =  s(x1, x2)
6.44/2.48	
6.44/2.48	U5_ga(x1, x2, x3)  =  U5_ga(x3)
6.44/2.48	
6.44/2.48	U6_ga(x1, x2, x3)  =  U6_ga(x3)
6.44/2.48	
6.44/2.48	U7_ga(x1, x2, x3)  =  U7_ga(x3)
6.44/2.48	
6.44/2.48	U8_ga(x1, x2, x3)  =  U8_ga(x3)
6.44/2.48	
6.44/2.48	U9_ga(x1, x2, x3)  =  U9_ga(x3)
6.44/2.48	
6.44/2.48	parse_out_ga(x1, x2)  =  parse_out_ga(x2)
6.44/2.48	
6.44/2.48	PARSE_IN_GA(x1, x2)  =  PARSE_IN_GA(x1)
6.44/2.48	
6.44/2.48	U1_GA(x1, x2, x3)  =  U1_GA(x3)
6.44/2.48	
6.44/2.48	APP_IN_AAG(x1, x2, x3)  =  APP_IN_AAG(x3)
6.44/2.48	
6.44/2.48	U10_AAG(x1, x2, x3, x4, x5)  =  U10_AAG(x1, x5)
6.77/2.48	
6.77/2.48	U2_GA(x1, x2, x3)  =  U2_GA(x3)
6.77/2.48	
6.77/2.48	APP_IN_GGA(x1, x2, x3)  =  APP_IN_GGA(x1, x2)
6.77/2.48	
6.77/2.48	U10_GGA(x1, x2, x3, x4, x5)  =  U10_GGA(x1, x5)
6.77/2.48	
6.77/2.48	U3_GA(x1, x2, x3)  =  U3_GA(x3)
6.77/2.48	
6.77/2.48	U4_GA(x1, x2, x3)  =  U4_GA(x3)
6.77/2.48	
6.77/2.48	U5_GA(x1, x2, x3)  =  U5_GA(x3)
6.77/2.48	
6.77/2.48	U6_GA(x1, x2, x3)  =  U6_GA(x3)
6.77/2.48	
6.77/2.48	U7_GA(x1, x2, x3)  =  U7_GA(x3)
6.77/2.48	
6.77/2.48	U8_GA(x1, x2, x3)  =  U8_GA(x3)
6.77/2.48	
6.77/2.48	U9_GA(x1, x2, x3)  =  U9_GA(x3)
6.77/2.48	
6.77/2.48	
6.77/2.48	We have to consider all (P,R,Pi)-chains
6.77/2.48	----------------------------------------
6.77/2.48	
6.77/2.48	(4)
6.77/2.48	Obligation:
6.77/2.48	Pi DP problem:
6.77/2.48	The TRS P consists of the following rules:
6.77/2.48	
6.77/2.48	   PARSE_IN_GA(Xs, T) -> U1_GA(Xs, T, app_in_aag(As, .(a, .(s(A, B, C), .(b, Bs))), Xs))
6.77/2.48	   PARSE_IN_GA(Xs, T) -> APP_IN_AAG(As, .(a, .(s(A, B, C), .(b, Bs))), Xs)
6.77/2.48	   APP_IN_AAG(.(X, Xs), Ys, .(X, Zs)) -> U10_AAG(X, Xs, Ys, Zs, app_in_aag(Xs, Ys, Zs))
6.77/2.48	   APP_IN_AAG(.(X, Xs), Ys, .(X, Zs)) -> APP_IN_AAG(Xs, Ys, Zs)
6.77/2.48	   U1_GA(Xs, T, app_out_aag(As, .(a, .(s(A, B, C), .(b, Bs))), Xs)) -> U2_GA(Xs, T, app_in_gga(As, .(s(a, s(A, B, C), b), Bs), Ys))
6.77/2.48	   U1_GA(Xs, T, app_out_aag(As, .(a, .(s(A, B, C), .(b, Bs))), Xs)) -> APP_IN_GGA(As, .(s(a, s(A, B, C), b), Bs), Ys)
6.77/2.48	   APP_IN_GGA(.(X, Xs), Ys, .(X, Zs)) -> U10_GGA(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
6.77/2.48	   APP_IN_GGA(.(X, Xs), Ys, .(X, Zs)) -> APP_IN_GGA(Xs, Ys, Zs)
6.77/2.48	   U2_GA(Xs, T, app_out_gga(As, .(s(a, s(A, B, C), b), Bs), Ys)) -> U3_GA(Xs, T, parse_in_ga(Ys, T))
6.77/2.48	   U2_GA(Xs, T, app_out_gga(As, .(s(a, s(A, B, C), b), Bs), Ys)) -> PARSE_IN_GA(Ys, T)
6.77/2.48	   PARSE_IN_GA(Xs, T) -> U4_GA(Xs, T, app_in_aag(As, .(a, .(s(A, B), .(b, Bs))), Xs))
6.77/2.48	   PARSE_IN_GA(Xs, T) -> APP_IN_AAG(As, .(a, .(s(A, B), .(b, Bs))), Xs)
6.77/2.48	   U4_GA(Xs, T, app_out_aag(As, .(a, .(s(A, B), .(b, Bs))), Xs)) -> U5_GA(Xs, T, app_in_gga(As, .(s(a, s(A, B), b), Bs), Ys))
6.77/2.48	   U4_GA(Xs, T, app_out_aag(As, .(a, .(s(A, B), .(b, Bs))), Xs)) -> APP_IN_GGA(As, .(s(a, s(A, B), b), Bs), Ys)
6.77/2.48	   U5_GA(Xs, T, app_out_gga(As, .(s(a, s(A, B), b), Bs), Ys)) -> U6_GA(Xs, T, parse_in_ga(Ys, T))
6.77/2.48	   U5_GA(Xs, T, app_out_gga(As, .(s(a, s(A, B), b), Bs), Ys)) -> PARSE_IN_GA(Ys, T)
6.77/2.48	   PARSE_IN_GA(Xs, T) -> U7_GA(Xs, T, app_in_aag(As, .(a, .(b, Bs)), Xs))
6.77/2.48	   PARSE_IN_GA(Xs, T) -> APP_IN_AAG(As, .(a, .(b, Bs)), Xs)
6.77/2.48	   U7_GA(Xs, T, app_out_aag(As, .(a, .(b, Bs)), Xs)) -> U8_GA(Xs, T, app_in_gga(As, .(s(a, b), Bs), Ys))
6.77/2.48	   U7_GA(Xs, T, app_out_aag(As, .(a, .(b, Bs)), Xs)) -> APP_IN_GGA(As, .(s(a, b), Bs), Ys)
6.77/2.48	   U8_GA(Xs, T, app_out_gga(As, .(s(a, b), Bs), Ys)) -> U9_GA(Xs, T, parse_in_ga(Ys, T))
6.77/2.48	   U8_GA(Xs, T, app_out_gga(As, .(s(a, b), Bs), Ys)) -> PARSE_IN_GA(Ys, T)
6.77/2.48	
6.77/2.48	The TRS R consists of the following rules:
6.77/2.48	
6.77/2.48	   parse_in_ga(Xs, T) -> U1_ga(Xs, T, app_in_aag(As, .(a, .(s(A, B, C), .(b, Bs))), Xs))
6.77/2.48	   app_in_aag([], X, X) -> app_out_aag([], X, X)
6.77/2.48	   app_in_aag(.(X, Xs), Ys, .(X, Zs)) -> U10_aag(X, Xs, Ys, Zs, app_in_aag(Xs, Ys, Zs))
6.77/2.48	   U10_aag(X, Xs, Ys, Zs, app_out_aag(Xs, Ys, Zs)) -> app_out_aag(.(X, Xs), Ys, .(X, Zs))
6.77/2.48	   U1_ga(Xs, T, app_out_aag(As, .(a, .(s(A, B, C), .(b, Bs))), Xs)) -> U2_ga(Xs, T, app_in_gga(As, .(s(a, s(A, B, C), b), Bs), Ys))
6.77/2.48	   app_in_gga([], X, X) -> app_out_gga([], X, X)
6.77/2.48	   app_in_gga(.(X, Xs), Ys, .(X, Zs)) -> U10_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
6.77/2.48	   U10_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) -> app_out_gga(.(X, Xs), Ys, .(X, Zs))
6.77/2.48	   U2_ga(Xs, T, app_out_gga(As, .(s(a, s(A, B, C), b), Bs), Ys)) -> U3_ga(Xs, T, parse_in_ga(Ys, T))
6.77/2.48	   parse_in_ga(Xs, T) -> U4_ga(Xs, T, app_in_aag(As, .(a, .(s(A, B), .(b, Bs))), Xs))
6.77/2.48	   U4_ga(Xs, T, app_out_aag(As, .(a, .(s(A, B), .(b, Bs))), Xs)) -> U5_ga(Xs, T, app_in_gga(As, .(s(a, s(A, B), b), Bs), Ys))
6.77/2.48	   U5_ga(Xs, T, app_out_gga(As, .(s(a, s(A, B), b), Bs), Ys)) -> U6_ga(Xs, T, parse_in_ga(Ys, T))
6.77/2.48	   parse_in_ga(Xs, T) -> U7_ga(Xs, T, app_in_aag(As, .(a, .(b, Bs)), Xs))
6.77/2.48	   U7_ga(Xs, T, app_out_aag(As, .(a, .(b, Bs)), Xs)) -> U8_ga(Xs, T, app_in_gga(As, .(s(a, b), Bs), Ys))
6.77/2.48	   U8_ga(Xs, T, app_out_gga(As, .(s(a, b), Bs), Ys)) -> U9_ga(Xs, T, parse_in_ga(Ys, T))
6.77/2.48	   parse_in_ga(.(s(A, B), []), s(A, B)) -> parse_out_ga(.(s(A, B), []), s(A, B))
6.77/2.48	   parse_in_ga(.(s(A, B, C), []), s(A, B, C)) -> parse_out_ga(.(s(A, B, C), []), s(A, B, C))
6.77/2.48	   U9_ga(Xs, T, parse_out_ga(Ys, T)) -> parse_out_ga(Xs, T)
6.77/2.48	   U6_ga(Xs, T, parse_out_ga(Ys, T)) -> parse_out_ga(Xs, T)
6.77/2.48	   U3_ga(Xs, T, parse_out_ga(Ys, T)) -> parse_out_ga(Xs, T)
6.77/2.48	
6.77/2.48	The argument filtering Pi contains the following mapping:
6.77/2.48	parse_in_ga(x1, x2)  =  parse_in_ga(x1)
6.77/2.48	
6.77/2.48	U1_ga(x1, x2, x3)  =  U1_ga(x3)
6.77/2.48	
6.77/2.48	app_in_aag(x1, x2, x3)  =  app_in_aag(x3)
6.77/2.48	
6.77/2.48	app_out_aag(x1, x2, x3)  =  app_out_aag(x1, x2)
6.77/2.48	
6.77/2.48	.(x1, x2)  =  .(x1, x2)
6.77/2.48	
6.77/2.48	U10_aag(x1, x2, x3, x4, x5)  =  U10_aag(x1, x5)
6.77/2.48	
6.77/2.48	a  =  a
6.77/2.48	
6.77/2.48	s(x1, x2, x3)  =  s(x1, x2, x3)
6.77/2.48	
6.77/2.48	b  =  b
6.77/2.48	
6.77/2.48	U2_ga(x1, x2, x3)  =  U2_ga(x3)
6.77/2.48	
6.77/2.48	app_in_gga(x1, x2, x3)  =  app_in_gga(x1, x2)
6.77/2.48	
6.77/2.48	[]  =  []
6.77/2.48	
6.77/2.48	app_out_gga(x1, x2, x3)  =  app_out_gga(x3)
6.77/2.48	
6.77/2.48	U10_gga(x1, x2, x3, x4, x5)  =  U10_gga(x1, x5)
6.77/2.48	
6.77/2.48	U3_ga(x1, x2, x3)  =  U3_ga(x3)
6.77/2.48	
6.77/2.48	U4_ga(x1, x2, x3)  =  U4_ga(x3)
6.77/2.48	
6.77/2.48	s(x1, x2)  =  s(x1, x2)
6.77/2.48	
6.77/2.48	U5_ga(x1, x2, x3)  =  U5_ga(x3)
6.77/2.48	
6.77/2.48	U6_ga(x1, x2, x3)  =  U6_ga(x3)
6.77/2.48	
6.77/2.48	U7_ga(x1, x2, x3)  =  U7_ga(x3)
6.77/2.48	
6.77/2.48	U8_ga(x1, x2, x3)  =  U8_ga(x3)
6.77/2.48	
6.77/2.48	U9_ga(x1, x2, x3)  =  U9_ga(x3)
6.77/2.48	
6.77/2.48	parse_out_ga(x1, x2)  =  parse_out_ga(x2)
6.77/2.48	
6.77/2.48	PARSE_IN_GA(x1, x2)  =  PARSE_IN_GA(x1)
6.77/2.48	
6.77/2.48	U1_GA(x1, x2, x3)  =  U1_GA(x3)
6.77/2.48	
6.77/2.48	APP_IN_AAG(x1, x2, x3)  =  APP_IN_AAG(x3)
6.77/2.48	
6.77/2.48	U10_AAG(x1, x2, x3, x4, x5)  =  U10_AAG(x1, x5)
6.77/2.48	
6.77/2.48	U2_GA(x1, x2, x3)  =  U2_GA(x3)
6.77/2.48	
6.77/2.48	APP_IN_GGA(x1, x2, x3)  =  APP_IN_GGA(x1, x2)
6.77/2.48	
6.77/2.48	U10_GGA(x1, x2, x3, x4, x5)  =  U10_GGA(x1, x5)
6.77/2.48	
6.77/2.48	U3_GA(x1, x2, x3)  =  U3_GA(x3)
6.77/2.48	
6.77/2.48	U4_GA(x1, x2, x3)  =  U4_GA(x3)
6.77/2.48	
6.77/2.48	U5_GA(x1, x2, x3)  =  U5_GA(x3)
6.77/2.48	
6.77/2.48	U6_GA(x1, x2, x3)  =  U6_GA(x3)
6.77/2.48	
6.77/2.48	U7_GA(x1, x2, x3)  =  U7_GA(x3)
6.77/2.48	
6.77/2.48	U8_GA(x1, x2, x3)  =  U8_GA(x3)
6.77/2.48	
6.77/2.48	U9_GA(x1, x2, x3)  =  U9_GA(x3)
6.77/2.48	
6.77/2.48	
6.77/2.48	We have to consider all (P,R,Pi)-chains
6.77/2.48	----------------------------------------
6.77/2.48	
6.77/2.48	(5) DependencyGraphProof (EQUIVALENT)
6.77/2.48	The approximation of the Dependency Graph [LOPSTR] contains 3 SCCs with 11 less nodes.
6.77/2.48	----------------------------------------
6.77/2.48	
6.77/2.48	(6)
6.77/2.48	Complex Obligation (AND)
6.77/2.48	
6.77/2.48	----------------------------------------
6.77/2.48	
6.77/2.48	(7)
6.77/2.48	Obligation:
6.77/2.48	Pi DP problem:
6.77/2.48	The TRS P consists of the following rules:
6.77/2.48	
6.77/2.48	   APP_IN_GGA(.(X, Xs), Ys, .(X, Zs)) -> APP_IN_GGA(Xs, Ys, Zs)
6.77/2.48	
6.77/2.48	The TRS R consists of the following rules:
6.77/2.48	
6.77/2.48	   parse_in_ga(Xs, T) -> U1_ga(Xs, T, app_in_aag(As, .(a, .(s(A, B, C), .(b, Bs))), Xs))
6.77/2.48	   app_in_aag([], X, X) -> app_out_aag([], X, X)
6.77/2.48	   app_in_aag(.(X, Xs), Ys, .(X, Zs)) -> U10_aag(X, Xs, Ys, Zs, app_in_aag(Xs, Ys, Zs))
6.77/2.48	   U10_aag(X, Xs, Ys, Zs, app_out_aag(Xs, Ys, Zs)) -> app_out_aag(.(X, Xs), Ys, .(X, Zs))
6.77/2.48	   U1_ga(Xs, T, app_out_aag(As, .(a, .(s(A, B, C), .(b, Bs))), Xs)) -> U2_ga(Xs, T, app_in_gga(As, .(s(a, s(A, B, C), b), Bs), Ys))
6.77/2.48	   app_in_gga([], X, X) -> app_out_gga([], X, X)
6.77/2.48	   app_in_gga(.(X, Xs), Ys, .(X, Zs)) -> U10_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
6.77/2.48	   U10_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) -> app_out_gga(.(X, Xs), Ys, .(X, Zs))
6.77/2.48	   U2_ga(Xs, T, app_out_gga(As, .(s(a, s(A, B, C), b), Bs), Ys)) -> U3_ga(Xs, T, parse_in_ga(Ys, T))
6.77/2.48	   parse_in_ga(Xs, T) -> U4_ga(Xs, T, app_in_aag(As, .(a, .(s(A, B), .(b, Bs))), Xs))
6.77/2.48	   U4_ga(Xs, T, app_out_aag(As, .(a, .(s(A, B), .(b, Bs))), Xs)) -> U5_ga(Xs, T, app_in_gga(As, .(s(a, s(A, B), b), Bs), Ys))
6.77/2.48	   U5_ga(Xs, T, app_out_gga(As, .(s(a, s(A, B), b), Bs), Ys)) -> U6_ga(Xs, T, parse_in_ga(Ys, T))
6.77/2.48	   parse_in_ga(Xs, T) -> U7_ga(Xs, T, app_in_aag(As, .(a, .(b, Bs)), Xs))
6.77/2.48	   U7_ga(Xs, T, app_out_aag(As, .(a, .(b, Bs)), Xs)) -> U8_ga(Xs, T, app_in_gga(As, .(s(a, b), Bs), Ys))
6.77/2.48	   U8_ga(Xs, T, app_out_gga(As, .(s(a, b), Bs), Ys)) -> U9_ga(Xs, T, parse_in_ga(Ys, T))
6.77/2.48	   parse_in_ga(.(s(A, B), []), s(A, B)) -> parse_out_ga(.(s(A, B), []), s(A, B))
6.77/2.48	   parse_in_ga(.(s(A, B, C), []), s(A, B, C)) -> parse_out_ga(.(s(A, B, C), []), s(A, B, C))
6.77/2.48	   U9_ga(Xs, T, parse_out_ga(Ys, T)) -> parse_out_ga(Xs, T)
6.77/2.48	   U6_ga(Xs, T, parse_out_ga(Ys, T)) -> parse_out_ga(Xs, T)
6.77/2.48	   U3_ga(Xs, T, parse_out_ga(Ys, T)) -> parse_out_ga(Xs, T)
6.77/2.48	
6.77/2.48	The argument filtering Pi contains the following mapping:
6.77/2.48	parse_in_ga(x1, x2)  =  parse_in_ga(x1)
6.77/2.48	
6.77/2.48	U1_ga(x1, x2, x3)  =  U1_ga(x3)
6.77/2.48	
6.77/2.48	app_in_aag(x1, x2, x3)  =  app_in_aag(x3)
6.77/2.48	
6.77/2.48	app_out_aag(x1, x2, x3)  =  app_out_aag(x1, x2)
6.77/2.48	
6.77/2.48	.(x1, x2)  =  .(x1, x2)
6.77/2.48	
6.77/2.48	U10_aag(x1, x2, x3, x4, x5)  =  U10_aag(x1, x5)
6.77/2.48	
6.77/2.48	a  =  a
6.77/2.48	
6.77/2.48	s(x1, x2, x3)  =  s(x1, x2, x3)
6.77/2.48	
6.77/2.48	b  =  b
6.77/2.48	
6.77/2.48	U2_ga(x1, x2, x3)  =  U2_ga(x3)
6.77/2.48	
6.77/2.48	app_in_gga(x1, x2, x3)  =  app_in_gga(x1, x2)
6.77/2.48	
6.77/2.48	[]  =  []
6.77/2.48	
6.77/2.48	app_out_gga(x1, x2, x3)  =  app_out_gga(x3)
6.77/2.48	
6.77/2.48	U10_gga(x1, x2, x3, x4, x5)  =  U10_gga(x1, x5)
6.77/2.48	
6.77/2.48	U3_ga(x1, x2, x3)  =  U3_ga(x3)
6.77/2.48	
6.77/2.48	U4_ga(x1, x2, x3)  =  U4_ga(x3)
6.77/2.48	
6.77/2.48	s(x1, x2)  =  s(x1, x2)
6.77/2.48	
6.77/2.48	U5_ga(x1, x2, x3)  =  U5_ga(x3)
6.77/2.48	
6.77/2.48	U6_ga(x1, x2, x3)  =  U6_ga(x3)
6.77/2.48	
6.77/2.48	U7_ga(x1, x2, x3)  =  U7_ga(x3)
6.77/2.48	
6.77/2.48	U8_ga(x1, x2, x3)  =  U8_ga(x3)
6.77/2.48	
6.77/2.48	U9_ga(x1, x2, x3)  =  U9_ga(x3)
6.77/2.48	
6.77/2.48	parse_out_ga(x1, x2)  =  parse_out_ga(x2)
6.77/2.48	
6.77/2.48	APP_IN_GGA(x1, x2, x3)  =  APP_IN_GGA(x1, x2)
6.77/2.48	
6.77/2.48	
6.77/2.48	We have to consider all (P,R,Pi)-chains
6.77/2.48	----------------------------------------
6.77/2.48	
6.77/2.48	(8) UsableRulesProof (EQUIVALENT)
6.77/2.48	For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
6.77/2.48	----------------------------------------
6.77/2.48	
6.77/2.48	(9)
6.77/2.48	Obligation:
6.77/2.48	Pi DP problem:
6.77/2.48	The TRS P consists of the following rules:
6.77/2.48	
6.77/2.48	   APP_IN_GGA(.(X, Xs), Ys, .(X, Zs)) -> APP_IN_GGA(Xs, Ys, Zs)
6.77/2.48	
6.77/2.48	R is empty.
6.77/2.48	The argument filtering Pi contains the following mapping:
6.77/2.48	.(x1, x2)  =  .(x1, x2)
6.77/2.48	
6.77/2.48	APP_IN_GGA(x1, x2, x3)  =  APP_IN_GGA(x1, x2)
6.77/2.48	
6.77/2.48	
6.77/2.48	We have to consider all (P,R,Pi)-chains
6.77/2.48	----------------------------------------
6.77/2.48	
6.77/2.48	(10) PiDPToQDPProof (SOUND)
6.77/2.48	Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
6.77/2.48	----------------------------------------
6.77/2.48	
6.77/2.48	(11)
6.77/2.48	Obligation:
6.77/2.48	Q DP problem:
6.77/2.48	The TRS P consists of the following rules:
6.77/2.48	
6.77/2.48	   APP_IN_GGA(.(X, Xs), Ys) -> APP_IN_GGA(Xs, Ys)
6.77/2.48	
6.77/2.48	R is empty.
6.77/2.48	Q is empty.
6.77/2.48	We have to consider all (P,Q,R)-chains.
6.77/2.48	----------------------------------------
6.77/2.48	
6.77/2.48	(12) QDPSizeChangeProof (EQUIVALENT)
6.77/2.48	By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. 
6.77/2.48	
6.77/2.48	From the DPs we obtained the following set of size-change graphs:
6.77/2.48	*APP_IN_GGA(.(X, Xs), Ys) -> APP_IN_GGA(Xs, Ys)
6.77/2.48	The graph contains the following edges 1 > 1, 2 >= 2
6.77/2.48	
6.77/2.48	
6.77/2.48	----------------------------------------
6.77/2.48	
6.77/2.48	(13)
6.77/2.48	YES
6.77/2.48	
6.77/2.48	----------------------------------------
6.77/2.48	
6.77/2.48	(14)
6.77/2.48	Obligation:
6.77/2.48	Pi DP problem:
6.77/2.48	The TRS P consists of the following rules:
6.77/2.48	
6.77/2.48	   APP_IN_AAG(.(X, Xs), Ys, .(X, Zs)) -> APP_IN_AAG(Xs, Ys, Zs)
6.77/2.48	
6.77/2.48	The TRS R consists of the following rules:
6.77/2.48	
6.77/2.48	   parse_in_ga(Xs, T) -> U1_ga(Xs, T, app_in_aag(As, .(a, .(s(A, B, C), .(b, Bs))), Xs))
6.77/2.48	   app_in_aag([], X, X) -> app_out_aag([], X, X)
6.77/2.48	   app_in_aag(.(X, Xs), Ys, .(X, Zs)) -> U10_aag(X, Xs, Ys, Zs, app_in_aag(Xs, Ys, Zs))
6.77/2.48	   U10_aag(X, Xs, Ys, Zs, app_out_aag(Xs, Ys, Zs)) -> app_out_aag(.(X, Xs), Ys, .(X, Zs))
6.77/2.48	   U1_ga(Xs, T, app_out_aag(As, .(a, .(s(A, B, C), .(b, Bs))), Xs)) -> U2_ga(Xs, T, app_in_gga(As, .(s(a, s(A, B, C), b), Bs), Ys))
6.77/2.48	   app_in_gga([], X, X) -> app_out_gga([], X, X)
6.77/2.48	   app_in_gga(.(X, Xs), Ys, .(X, Zs)) -> U10_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
6.77/2.48	   U10_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) -> app_out_gga(.(X, Xs), Ys, .(X, Zs))
6.77/2.48	   U2_ga(Xs, T, app_out_gga(As, .(s(a, s(A, B, C), b), Bs), Ys)) -> U3_ga(Xs, T, parse_in_ga(Ys, T))
6.77/2.48	   parse_in_ga(Xs, T) -> U4_ga(Xs, T, app_in_aag(As, .(a, .(s(A, B), .(b, Bs))), Xs))
6.77/2.48	   U4_ga(Xs, T, app_out_aag(As, .(a, .(s(A, B), .(b, Bs))), Xs)) -> U5_ga(Xs, T, app_in_gga(As, .(s(a, s(A, B), b), Bs), Ys))
6.77/2.48	   U5_ga(Xs, T, app_out_gga(As, .(s(a, s(A, B), b), Bs), Ys)) -> U6_ga(Xs, T, parse_in_ga(Ys, T))
6.77/2.48	   parse_in_ga(Xs, T) -> U7_ga(Xs, T, app_in_aag(As, .(a, .(b, Bs)), Xs))
6.77/2.48	   U7_ga(Xs, T, app_out_aag(As, .(a, .(b, Bs)), Xs)) -> U8_ga(Xs, T, app_in_gga(As, .(s(a, b), Bs), Ys))
6.77/2.48	   U8_ga(Xs, T, app_out_gga(As, .(s(a, b), Bs), Ys)) -> U9_ga(Xs, T, parse_in_ga(Ys, T))
6.77/2.48	   parse_in_ga(.(s(A, B), []), s(A, B)) -> parse_out_ga(.(s(A, B), []), s(A, B))
6.77/2.48	   parse_in_ga(.(s(A, B, C), []), s(A, B, C)) -> parse_out_ga(.(s(A, B, C), []), s(A, B, C))
6.77/2.48	   U9_ga(Xs, T, parse_out_ga(Ys, T)) -> parse_out_ga(Xs, T)
6.77/2.48	   U6_ga(Xs, T, parse_out_ga(Ys, T)) -> parse_out_ga(Xs, T)
6.77/2.48	   U3_ga(Xs, T, parse_out_ga(Ys, T)) -> parse_out_ga(Xs, T)
6.77/2.48	
6.77/2.48	The argument filtering Pi contains the following mapping:
6.77/2.48	parse_in_ga(x1, x2)  =  parse_in_ga(x1)
6.77/2.48	
6.77/2.48	U1_ga(x1, x2, x3)  =  U1_ga(x3)
6.77/2.48	
6.77/2.48	app_in_aag(x1, x2, x3)  =  app_in_aag(x3)
6.77/2.48	
6.77/2.48	app_out_aag(x1, x2, x3)  =  app_out_aag(x1, x2)
6.77/2.48	
6.77/2.48	.(x1, x2)  =  .(x1, x2)
6.77/2.48	
6.77/2.48	U10_aag(x1, x2, x3, x4, x5)  =  U10_aag(x1, x5)
6.77/2.48	
6.77/2.48	a  =  a
6.77/2.48	
6.77/2.48	s(x1, x2, x3)  =  s(x1, x2, x3)
6.77/2.48	
6.77/2.48	b  =  b
6.77/2.48	
6.77/2.48	U2_ga(x1, x2, x3)  =  U2_ga(x3)
6.77/2.48	
6.77/2.48	app_in_gga(x1, x2, x3)  =  app_in_gga(x1, x2)
6.77/2.48	
6.77/2.48	[]  =  []
6.77/2.48	
6.77/2.48	app_out_gga(x1, x2, x3)  =  app_out_gga(x3)
6.77/2.48	
6.77/2.48	U10_gga(x1, x2, x3, x4, x5)  =  U10_gga(x1, x5)
6.77/2.48	
6.77/2.48	U3_ga(x1, x2, x3)  =  U3_ga(x3)
6.77/2.48	
6.77/2.48	U4_ga(x1, x2, x3)  =  U4_ga(x3)
6.77/2.48	
6.77/2.48	s(x1, x2)  =  s(x1, x2)
6.77/2.48	
6.77/2.48	U5_ga(x1, x2, x3)  =  U5_ga(x3)
6.77/2.48	
6.77/2.48	U6_ga(x1, x2, x3)  =  U6_ga(x3)
6.77/2.48	
6.77/2.48	U7_ga(x1, x2, x3)  =  U7_ga(x3)
6.77/2.48	
6.77/2.48	U8_ga(x1, x2, x3)  =  U8_ga(x3)
6.77/2.48	
6.77/2.48	U9_ga(x1, x2, x3)  =  U9_ga(x3)
6.77/2.48	
6.77/2.48	parse_out_ga(x1, x2)  =  parse_out_ga(x2)
6.77/2.48	
6.77/2.48	APP_IN_AAG(x1, x2, x3)  =  APP_IN_AAG(x3)
6.77/2.48	
6.77/2.48	
6.77/2.48	We have to consider all (P,R,Pi)-chains
6.77/2.48	----------------------------------------
6.77/2.48	
6.77/2.48	(15) UsableRulesProof (EQUIVALENT)
6.77/2.48	For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
6.77/2.48	----------------------------------------
6.77/2.48	
6.77/2.48	(16)
6.77/2.48	Obligation:
6.77/2.48	Pi DP problem:
6.77/2.48	The TRS P consists of the following rules:
6.77/2.48	
6.77/2.48	   APP_IN_AAG(.(X, Xs), Ys, .(X, Zs)) -> APP_IN_AAG(Xs, Ys, Zs)
6.77/2.48	
6.77/2.48	R is empty.
6.77/2.48	The argument filtering Pi contains the following mapping:
6.77/2.48	.(x1, x2)  =  .(x1, x2)
6.77/2.48	
6.77/2.48	APP_IN_AAG(x1, x2, x3)  =  APP_IN_AAG(x3)
6.77/2.48	
6.77/2.48	
6.77/2.48	We have to consider all (P,R,Pi)-chains
6.77/2.48	----------------------------------------
6.77/2.48	
6.77/2.48	(17) PiDPToQDPProof (SOUND)
6.77/2.48	Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
6.77/2.48	----------------------------------------
6.77/2.48	
6.77/2.48	(18)
6.77/2.48	Obligation:
6.77/2.48	Q DP problem:
6.77/2.48	The TRS P consists of the following rules:
6.77/2.48	
6.77/2.48	   APP_IN_AAG(.(X, Zs)) -> APP_IN_AAG(Zs)
6.77/2.48	
6.77/2.48	R is empty.
6.77/2.48	Q is empty.
6.77/2.48	We have to consider all (P,Q,R)-chains.
6.77/2.48	----------------------------------------
6.77/2.48	
6.77/2.48	(19) QDPSizeChangeProof (EQUIVALENT)
6.77/2.48	By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. 
6.77/2.48	
6.77/2.48	From the DPs we obtained the following set of size-change graphs:
6.77/2.48	*APP_IN_AAG(.(X, Zs)) -> APP_IN_AAG(Zs)
6.77/2.48	The graph contains the following edges 1 > 1
6.77/2.48	
6.77/2.48	
6.77/2.48	----------------------------------------
6.77/2.48	
6.77/2.48	(20)
6.77/2.48	YES
6.77/2.48	
6.77/2.48	----------------------------------------
6.77/2.48	
6.77/2.48	(21)
6.77/2.48	Obligation:
6.77/2.48	Pi DP problem:
6.77/2.48	The TRS P consists of the following rules:
6.77/2.48	
6.77/2.48	   U1_GA(Xs, T, app_out_aag(As, .(a, .(s(A, B, C), .(b, Bs))), Xs)) -> U2_GA(Xs, T, app_in_gga(As, .(s(a, s(A, B, C), b), Bs), Ys))
6.77/2.48	   U2_GA(Xs, T, app_out_gga(As, .(s(a, s(A, B, C), b), Bs), Ys)) -> PARSE_IN_GA(Ys, T)
6.77/2.48	   PARSE_IN_GA(Xs, T) -> U1_GA(Xs, T, app_in_aag(As, .(a, .(s(A, B, C), .(b, Bs))), Xs))
6.77/2.48	   PARSE_IN_GA(Xs, T) -> U4_GA(Xs, T, app_in_aag(As, .(a, .(s(A, B), .(b, Bs))), Xs))
6.77/2.48	   U4_GA(Xs, T, app_out_aag(As, .(a, .(s(A, B), .(b, Bs))), Xs)) -> U5_GA(Xs, T, app_in_gga(As, .(s(a, s(A, B), b), Bs), Ys))
6.77/2.48	   U5_GA(Xs, T, app_out_gga(As, .(s(a, s(A, B), b), Bs), Ys)) -> PARSE_IN_GA(Ys, T)
6.77/2.48	   PARSE_IN_GA(Xs, T) -> U7_GA(Xs, T, app_in_aag(As, .(a, .(b, Bs)), Xs))
6.77/2.48	   U7_GA(Xs, T, app_out_aag(As, .(a, .(b, Bs)), Xs)) -> U8_GA(Xs, T, app_in_gga(As, .(s(a, b), Bs), Ys))
6.77/2.48	   U8_GA(Xs, T, app_out_gga(As, .(s(a, b), Bs), Ys)) -> PARSE_IN_GA(Ys, T)
6.77/2.48	
6.77/2.48	The TRS R consists of the following rules:
6.77/2.48	
6.77/2.48	   parse_in_ga(Xs, T) -> U1_ga(Xs, T, app_in_aag(As, .(a, .(s(A, B, C), .(b, Bs))), Xs))
6.77/2.48	   app_in_aag([], X, X) -> app_out_aag([], X, X)
6.77/2.48	   app_in_aag(.(X, Xs), Ys, .(X, Zs)) -> U10_aag(X, Xs, Ys, Zs, app_in_aag(Xs, Ys, Zs))
6.77/2.48	   U10_aag(X, Xs, Ys, Zs, app_out_aag(Xs, Ys, Zs)) -> app_out_aag(.(X, Xs), Ys, .(X, Zs))
6.77/2.48	   U1_ga(Xs, T, app_out_aag(As, .(a, .(s(A, B, C), .(b, Bs))), Xs)) -> U2_ga(Xs, T, app_in_gga(As, .(s(a, s(A, B, C), b), Bs), Ys))
6.77/2.48	   app_in_gga([], X, X) -> app_out_gga([], X, X)
6.77/2.48	   app_in_gga(.(X, Xs), Ys, .(X, Zs)) -> U10_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
6.77/2.48	   U10_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) -> app_out_gga(.(X, Xs), Ys, .(X, Zs))
6.77/2.48	   U2_ga(Xs, T, app_out_gga(As, .(s(a, s(A, B, C), b), Bs), Ys)) -> U3_ga(Xs, T, parse_in_ga(Ys, T))
6.77/2.48	   parse_in_ga(Xs, T) -> U4_ga(Xs, T, app_in_aag(As, .(a, .(s(A, B), .(b, Bs))), Xs))
6.77/2.48	   U4_ga(Xs, T, app_out_aag(As, .(a, .(s(A, B), .(b, Bs))), Xs)) -> U5_ga(Xs, T, app_in_gga(As, .(s(a, s(A, B), b), Bs), Ys))
6.77/2.48	   U5_ga(Xs, T, app_out_gga(As, .(s(a, s(A, B), b), Bs), Ys)) -> U6_ga(Xs, T, parse_in_ga(Ys, T))
6.77/2.48	   parse_in_ga(Xs, T) -> U7_ga(Xs, T, app_in_aag(As, .(a, .(b, Bs)), Xs))
6.77/2.48	   U7_ga(Xs, T, app_out_aag(As, .(a, .(b, Bs)), Xs)) -> U8_ga(Xs, T, app_in_gga(As, .(s(a, b), Bs), Ys))
6.77/2.48	   U8_ga(Xs, T, app_out_gga(As, .(s(a, b), Bs), Ys)) -> U9_ga(Xs, T, parse_in_ga(Ys, T))
6.77/2.48	   parse_in_ga(.(s(A, B), []), s(A, B)) -> parse_out_ga(.(s(A, B), []), s(A, B))
6.77/2.48	   parse_in_ga(.(s(A, B, C), []), s(A, B, C)) -> parse_out_ga(.(s(A, B, C), []), s(A, B, C))
6.77/2.48	   U9_ga(Xs, T, parse_out_ga(Ys, T)) -> parse_out_ga(Xs, T)
6.77/2.48	   U6_ga(Xs, T, parse_out_ga(Ys, T)) -> parse_out_ga(Xs, T)
6.77/2.48	   U3_ga(Xs, T, parse_out_ga(Ys, T)) -> parse_out_ga(Xs, T)
6.77/2.48	
6.77/2.48	The argument filtering Pi contains the following mapping:
6.77/2.48	parse_in_ga(x1, x2)  =  parse_in_ga(x1)
6.77/2.48	
6.77/2.48	U1_ga(x1, x2, x3)  =  U1_ga(x3)
6.77/2.48	
6.77/2.48	app_in_aag(x1, x2, x3)  =  app_in_aag(x3)
6.77/2.48	
6.77/2.48	app_out_aag(x1, x2, x3)  =  app_out_aag(x1, x2)
6.77/2.49	
6.77/2.49	.(x1, x2)  =  .(x1, x2)
6.77/2.49	
6.77/2.49	U10_aag(x1, x2, x3, x4, x5)  =  U10_aag(x1, x5)
6.77/2.49	
6.77/2.49	a  =  a
6.77/2.49	
6.77/2.49	s(x1, x2, x3)  =  s(x1, x2, x3)
6.77/2.49	
6.77/2.49	b  =  b
6.77/2.49	
6.77/2.49	U2_ga(x1, x2, x3)  =  U2_ga(x3)
6.77/2.49	
6.77/2.49	app_in_gga(x1, x2, x3)  =  app_in_gga(x1, x2)
6.77/2.49	
6.77/2.49	[]  =  []
6.77/2.49	
6.77/2.49	app_out_gga(x1, x2, x3)  =  app_out_gga(x3)
6.77/2.49	
6.77/2.49	U10_gga(x1, x2, x3, x4, x5)  =  U10_gga(x1, x5)
6.77/2.49	
6.77/2.49	U3_ga(x1, x2, x3)  =  U3_ga(x3)
6.77/2.49	
6.77/2.49	U4_ga(x1, x2, x3)  =  U4_ga(x3)
6.77/2.49	
6.77/2.49	s(x1, x2)  =  s(x1, x2)
6.77/2.49	
6.77/2.49	U5_ga(x1, x2, x3)  =  U5_ga(x3)
6.77/2.49	
6.77/2.49	U6_ga(x1, x2, x3)  =  U6_ga(x3)
6.77/2.49	
6.77/2.49	U7_ga(x1, x2, x3)  =  U7_ga(x3)
6.77/2.49	
6.77/2.49	U8_ga(x1, x2, x3)  =  U8_ga(x3)
6.77/2.49	
6.77/2.49	U9_ga(x1, x2, x3)  =  U9_ga(x3)
6.77/2.49	
6.77/2.49	parse_out_ga(x1, x2)  =  parse_out_ga(x2)
6.77/2.49	
6.77/2.49	PARSE_IN_GA(x1, x2)  =  PARSE_IN_GA(x1)
6.77/2.49	
6.77/2.49	U1_GA(x1, x2, x3)  =  U1_GA(x3)
6.77/2.49	
6.77/2.49	U2_GA(x1, x2, x3)  =  U2_GA(x3)
6.77/2.49	
6.77/2.49	U4_GA(x1, x2, x3)  =  U4_GA(x3)
6.77/2.49	
6.77/2.49	U5_GA(x1, x2, x3)  =  U5_GA(x3)
6.77/2.49	
6.77/2.49	U7_GA(x1, x2, x3)  =  U7_GA(x3)
6.77/2.49	
6.77/2.49	U8_GA(x1, x2, x3)  =  U8_GA(x3)
6.77/2.49	
6.77/2.49	
6.77/2.49	We have to consider all (P,R,Pi)-chains
6.77/2.49	----------------------------------------
6.77/2.49	
6.77/2.49	(22) UsableRulesProof (EQUIVALENT)
6.77/2.49	For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
6.77/2.49	----------------------------------------
6.77/2.49	
6.77/2.49	(23)
6.77/2.49	Obligation:
6.77/2.49	Pi DP problem:
6.77/2.49	The TRS P consists of the following rules:
6.77/2.49	
6.77/2.49	   U1_GA(Xs, T, app_out_aag(As, .(a, .(s(A, B, C), .(b, Bs))), Xs)) -> U2_GA(Xs, T, app_in_gga(As, .(s(a, s(A, B, C), b), Bs), Ys))
6.77/2.49	   U2_GA(Xs, T, app_out_gga(As, .(s(a, s(A, B, C), b), Bs), Ys)) -> PARSE_IN_GA(Ys, T)
6.77/2.49	   PARSE_IN_GA(Xs, T) -> U1_GA(Xs, T, app_in_aag(As, .(a, .(s(A, B, C), .(b, Bs))), Xs))
6.77/2.49	   PARSE_IN_GA(Xs, T) -> U4_GA(Xs, T, app_in_aag(As, .(a, .(s(A, B), .(b, Bs))), Xs))
6.77/2.49	   U4_GA(Xs, T, app_out_aag(As, .(a, .(s(A, B), .(b, Bs))), Xs)) -> U5_GA(Xs, T, app_in_gga(As, .(s(a, s(A, B), b), Bs), Ys))
6.77/2.49	   U5_GA(Xs, T, app_out_gga(As, .(s(a, s(A, B), b), Bs), Ys)) -> PARSE_IN_GA(Ys, T)
6.77/2.49	   PARSE_IN_GA(Xs, T) -> U7_GA(Xs, T, app_in_aag(As, .(a, .(b, Bs)), Xs))
6.77/2.49	   U7_GA(Xs, T, app_out_aag(As, .(a, .(b, Bs)), Xs)) -> U8_GA(Xs, T, app_in_gga(As, .(s(a, b), Bs), Ys))
6.77/2.49	   U8_GA(Xs, T, app_out_gga(As, .(s(a, b), Bs), Ys)) -> PARSE_IN_GA(Ys, T)
6.77/2.49	
6.77/2.49	The TRS R consists of the following rules:
6.77/2.49	
6.77/2.49	   app_in_gga([], X, X) -> app_out_gga([], X, X)
6.77/2.49	   app_in_gga(.(X, Xs), Ys, .(X, Zs)) -> U10_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
6.77/2.49	   app_in_aag([], X, X) -> app_out_aag([], X, X)
6.77/2.49	   app_in_aag(.(X, Xs), Ys, .(X, Zs)) -> U10_aag(X, Xs, Ys, Zs, app_in_aag(Xs, Ys, Zs))
6.77/2.49	   U10_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) -> app_out_gga(.(X, Xs), Ys, .(X, Zs))
6.77/2.49	   U10_aag(X, Xs, Ys, Zs, app_out_aag(Xs, Ys, Zs)) -> app_out_aag(.(X, Xs), Ys, .(X, Zs))
6.77/2.49	
6.77/2.49	The argument filtering Pi contains the following mapping:
6.77/2.49	app_in_aag(x1, x2, x3)  =  app_in_aag(x3)
6.77/2.49	
6.77/2.49	app_out_aag(x1, x2, x3)  =  app_out_aag(x1, x2)
6.77/2.49	
6.77/2.49	.(x1, x2)  =  .(x1, x2)
6.77/2.49	
6.77/2.49	U10_aag(x1, x2, x3, x4, x5)  =  U10_aag(x1, x5)
6.77/2.49	
6.77/2.49	a  =  a
6.77/2.49	
6.77/2.49	s(x1, x2, x3)  =  s(x1, x2, x3)
6.77/2.49	
6.77/2.49	b  =  b
6.77/2.49	
6.77/2.49	app_in_gga(x1, x2, x3)  =  app_in_gga(x1, x2)
6.77/2.49	
6.77/2.49	[]  =  []
6.77/2.49	
6.77/2.49	app_out_gga(x1, x2, x3)  =  app_out_gga(x3)
6.77/2.49	
6.77/2.49	U10_gga(x1, x2, x3, x4, x5)  =  U10_gga(x1, x5)
6.77/2.49	
6.77/2.49	s(x1, x2)  =  s(x1, x2)
6.77/2.49	
6.77/2.49	PARSE_IN_GA(x1, x2)  =  PARSE_IN_GA(x1)
6.77/2.49	
6.77/2.49	U1_GA(x1, x2, x3)  =  U1_GA(x3)
6.77/2.49	
6.77/2.49	U2_GA(x1, x2, x3)  =  U2_GA(x3)
6.77/2.49	
6.77/2.49	U4_GA(x1, x2, x3)  =  U4_GA(x3)
6.77/2.49	
6.77/2.49	U5_GA(x1, x2, x3)  =  U5_GA(x3)
6.77/2.49	
6.77/2.49	U7_GA(x1, x2, x3)  =  U7_GA(x3)
6.77/2.49	
6.77/2.49	U8_GA(x1, x2, x3)  =  U8_GA(x3)
6.77/2.49	
6.77/2.49	
6.77/2.49	We have to consider all (P,R,Pi)-chains
6.77/2.49	----------------------------------------
6.77/2.49	
6.77/2.49	(24) PiDPToQDPProof (SOUND)
6.77/2.49	Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
6.77/2.49	----------------------------------------
6.77/2.49	
6.77/2.49	(25)
6.77/2.49	Obligation:
6.77/2.49	Q DP problem:
6.77/2.49	The TRS P consists of the following rules:
6.77/2.49	
6.77/2.49	   U1_GA(app_out_aag(As, .(a, .(s(A, B, C), .(b, Bs))))) -> U2_GA(app_in_gga(As, .(s(a, s(A, B, C), b), Bs)))
6.77/2.49	   U2_GA(app_out_gga(Ys)) -> PARSE_IN_GA(Ys)
6.77/2.49	   PARSE_IN_GA(Xs) -> U1_GA(app_in_aag(Xs))
6.77/2.49	   PARSE_IN_GA(Xs) -> U4_GA(app_in_aag(Xs))
6.77/2.49	   U4_GA(app_out_aag(As, .(a, .(s(A, B), .(b, Bs))))) -> U5_GA(app_in_gga(As, .(s(a, s(A, B), b), Bs)))
6.77/2.49	   U5_GA(app_out_gga(Ys)) -> PARSE_IN_GA(Ys)
6.77/2.49	   PARSE_IN_GA(Xs) -> U7_GA(app_in_aag(Xs))
6.77/2.49	   U7_GA(app_out_aag(As, .(a, .(b, Bs)))) -> U8_GA(app_in_gga(As, .(s(a, b), Bs)))
6.77/2.49	   U8_GA(app_out_gga(Ys)) -> PARSE_IN_GA(Ys)
6.77/2.49	
6.77/2.49	The TRS R consists of the following rules:
6.77/2.49	
6.77/2.49	   app_in_gga([], X) -> app_out_gga(X)
6.77/2.49	   app_in_gga(.(X, Xs), Ys) -> U10_gga(X, app_in_gga(Xs, Ys))
6.77/2.49	   app_in_aag(X) -> app_out_aag([], X)
6.77/2.49	   app_in_aag(.(X, Zs)) -> U10_aag(X, app_in_aag(Zs))
6.77/2.49	   U10_gga(X, app_out_gga(Zs)) -> app_out_gga(.(X, Zs))
6.77/2.49	   U10_aag(X, app_out_aag(Xs, Ys)) -> app_out_aag(.(X, Xs), Ys)
6.77/2.49	
6.77/2.49	The set Q consists of the following terms:
6.77/2.49	
6.77/2.49	   app_in_gga(x0, x1)
6.77/2.49	   app_in_aag(x0)
6.77/2.49	   U10_gga(x0, x1)
6.77/2.49	   U10_aag(x0, x1)
6.77/2.49	
6.77/2.49	We have to consider all (P,Q,R)-chains.
6.77/2.49	----------------------------------------
6.77/2.49	
6.77/2.49	(26) MRRProof (EQUIVALENT)
6.77/2.49	By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
6.77/2.49	
6.77/2.49	Strictly oriented dependency pairs:
6.77/2.49	
6.77/2.49	   U1_GA(app_out_aag(As, .(a, .(s(A, B, C), .(b, Bs))))) -> U2_GA(app_in_gga(As, .(s(a, s(A, B, C), b), Bs)))
6.77/2.49	   U2_GA(app_out_gga(Ys)) -> PARSE_IN_GA(Ys)
6.77/2.49	   PARSE_IN_GA(Xs) -> U1_GA(app_in_aag(Xs))
6.77/2.49	   PARSE_IN_GA(Xs) -> U4_GA(app_in_aag(Xs))
6.77/2.49	   U4_GA(app_out_aag(As, .(a, .(s(A, B), .(b, Bs))))) -> U5_GA(app_in_gga(As, .(s(a, s(A, B), b), Bs)))
6.77/2.49	   U5_GA(app_out_gga(Ys)) -> PARSE_IN_GA(Ys)
6.77/2.49	   PARSE_IN_GA(Xs) -> U7_GA(app_in_aag(Xs))
6.77/2.49	   U7_GA(app_out_aag(As, .(a, .(b, Bs)))) -> U8_GA(app_in_gga(As, .(s(a, b), Bs)))
6.77/2.49	   U8_GA(app_out_gga(Ys)) -> PARSE_IN_GA(Ys)
6.77/2.49	
6.77/2.49	Strictly oriented rules of the TRS R:
6.77/2.49	
6.77/2.49	   app_in_gga([], X) -> app_out_gga(X)
6.77/2.49	   app_in_gga(.(X, Xs), Ys) -> U10_gga(X, app_in_gga(Xs, Ys))
6.77/2.49	   app_in_aag(X) -> app_out_aag([], X)
6.77/2.49	   app_in_aag(.(X, Zs)) -> U10_aag(X, app_in_aag(Zs))
6.77/2.49	   U10_gga(X, app_out_gga(Zs)) -> app_out_gga(.(X, Zs))
6.77/2.49	   U10_aag(X, app_out_aag(Xs, Ys)) -> app_out_aag(.(X, Xs), Ys)
6.77/2.49	
6.77/2.49	Used ordering: Knuth-Bendix order [KBO] with precedence:U7_GA_1 > app_in_gga_2 > U4_GA_1 > U5_GA_1 > U10_gga_2 > s_2 > app_in_aag_1 > U10_aag_2 > U8_GA_1 > app_out_gga_1 > U2_GA_1 > [] > PARSE_IN_GA_1 > a > ._2 > app_out_aag_2 > b > s_3 > U1_GA_1
6.77/2.49	
6.77/2.49	and weight map:
6.77/2.49	
6.77/2.49	   []=2
6.77/2.49	   a=1
6.77/2.49	   b=1
6.77/2.49	   app_out_gga_1=7
6.77/2.49	   app_in_aag_1=3
6.77/2.49	   U1_GA_1=3
6.77/2.49	   U2_GA_1=1
6.77/2.49	   PARSE_IN_GA_1=8
6.77/2.49	   U4_GA_1=3
6.77/2.49	   U5_GA_1=2
6.77/2.49	   U7_GA_1=3
6.77/2.49	   U8_GA_1=2
6.77/2.49	   app_in_gga_2=6
6.77/2.49	   ._2=5
6.77/2.49	   U10_gga_2=5
6.77/2.49	   app_out_aag_2=0
6.77/2.49	   U10_aag_2=5
6.77/2.49	   s_3=5
6.77/2.49	   s_2=0
6.77/2.49	
6.77/2.49	The variable weight is 1
6.77/2.49	
6.77/2.49	----------------------------------------
6.77/2.49	
6.77/2.49	(27)
6.77/2.49	Obligation:
6.77/2.49	Q DP problem:
6.77/2.49	P is empty.
6.77/2.49	R is empty.
6.77/2.49	The set Q consists of the following terms:
6.77/2.49	
6.77/2.49	   app_in_gga(x0, x1)
6.77/2.49	   app_in_aag(x0)
6.77/2.49	   U10_gga(x0, x1)
6.77/2.49	   U10_aag(x0, x1)
6.77/2.49	
6.77/2.49	We have to consider all (P,Q,R)-chains.
6.77/2.49	----------------------------------------
6.77/2.49	
6.77/2.49	(28) PisEmptyProof (EQUIVALENT)
6.77/2.49	The TRS P is empty. Hence, there is no (P,Q,R) chain.
6.77/2.49	----------------------------------------
6.77/2.49	
6.77/2.49	(29)
6.77/2.49	YES
6.80/2.53	EOF