Morphocompletion for #4173 ⟨a, b | aabbabaab=ba⟩

Solved by morph:4/0,2/0. (See Morphocompletion.)

Step 1

Checking up to 20 rules for overlaps.

Reduction order:
- Right-to-left recursive path with deg(a) = 0; deg(b) = 1

Rewriting system is not complete: arenaTotalLimit

#	Rule
1.	aabbabaab ⇒ ba
2.	aabbabba ⇒ bababaab
3.	bababaababbabaab ⇒ aabbabbba
4.	aabbabaaaabbabbba ⇒ baababaababbabaab
5.	bababaababbabba ⇒ aabbabbbababaab
6.	aabbaaabbabaaaabbabbbba ⇒ baabaababbabaababbabaab
7.	baababaababbabaababbabaab ⇒ aabbabaaaabbabbbba
8.	aabbabaaaabbabaaaabbabbbba ⇒ baaababaababbabaababbabaab
9.	bababaababbabaaaabbabbba ⇒ aabbabbbaababaababbabaab
10.	baababaababbabaababbabba ⇒ aabbabaaaabbabbbbababaab
11.	aabbaaabbaaabbabaaaabbabbbbba ⇒ baaababbabaababbabaababbabaab
12.	baabaababbabaababbabaababbabaab ⇒ aabbaaabbabaaaabbabbbbba
	...

Collecting factors up to length 7 / frequency 4:

[2/0]	ba	88	`lf:74,lp:6,ls:8,rf:65,rp:6,rs:4,re:1,lsrp:5,lprs:3`
[2/1]	ab	76	`lf:72,ls:4,rf:67,rs:8`
[2/2]	aa	53	`lf:47,lp:6,rf:40,rp:6`
[2/3]	bb	42	`lf:42,rf:35`
[3/0]	bab	43	`lf:40,lp:3,rf:36,rp:1`
[3/1]	aab	42	`lf:32,lp:6,ls:4,rf:31,rp:6,rs:8,lsrp:3,lprs:5`
[3/2]	bba	41	`lf:33,ls:8,rf:25,rs:3`
[3/3]	aba	35	`lf:35,rf:34`
[4/0]	abba	31	`lf:28,ls:3,rf:19`
[4/1]	baba	25	`lf:22,lp:3,rf:21,rp:1`
[4/2]	baab	24	`lf:17,lp:3,ls:4,rf:19,rp:2,rs:8,lprs:1`
[4/3]	bbab	22	`lf:22,rf:20`
[5/0]	abbab	22	`lf:22,rf:18`
[5/1]	aabba	21	`lf:15,lp:6,rf:10,rp:6`
[5/2]	babaa	19	`lf:19,rf:18`
[5/3]	abaab	18	`lf:14,ls:4,rf:16,rs:8`
[6/0]	babaab	17	`lf:13,ls:4,rf:15,rs:8`
[6/1]	aabbab	16	`lf:12,lp:4,rf:9,rp:5`
[6/2]	bbabaa	14	`lf:14,rf:12`
[6/3]	abbaba	14	`lf:14,rf:12`

Considering [length 4 / frequency 0] abba=c.

Step 2

Checking up to 20 rules for overlaps.

Auxiliary generators:
1. c = abba
Reduction order:
- Right-to-left recursive path with deg(a) = deg(c) = 0, a < c; deg(b) = 1

Rewriting system is not complete: pendingRulesLimit

#	Rule
1.	acbaab ⇒ ba
2.	abba ⇒ c
3.	baba ⇒ acbac
4.	abbc ⇒ cbba
5.	abacbac ⇒ cba
6.	baacbac ⇒ acbacba
7.	acbaccbac ⇒ bcba
8.	acbaaacbac ⇒ baaba
9.	acbaccbaab ⇒ bc
10.	abbba ⇒ ccbaab
11.	abacbba ⇒ cacbacab
12.	acbacbba ⇒ babc
13.	acbaccbba ⇒ bcacbacab
14.	abbbc ⇒ ccbaccbaab
15.	acbacbacbac ⇒ babcba
16.	babcacbacab ⇒ acbbabc
17.	abbbba ⇒ ccbaabcbaab
18.	acbacbbba ⇒ babccbaab
19.	babcbba ⇒ acbacbbc
	...

Collecting factors up to length 6 / frequency 7:

[2/0]	ba	44	`lf:31,lp:4,ls:9,rf:23,rp:5,rs:7,re:1,lsrp:2,lprs:1,a:1`
[2/1]	ac	39	`lf:26,lp:8,ls:5,rf:12,rp:4,rs:1,lsrp:1,a:2`
[2/2]	ab	23	`lf:13,lp:7,ls:3,rf:12,rs:6,lprs:4,a:1`
[2/3]	cb	21	`lf:21,rf:18,rp:2,a:2`
[2/4]	bb	15	`lf:15,rf:3,a:1`
[2/5]	bc	6	`lf:4,ls:2,rf:9,rp:3,rs:4,re:1,a:3`
[2/6]	aa	5	`lf:5,rf:6,a:2`
[3/0]	acb	25	`lf:17,lp:8,rf:8,rp:4,a:2`
[3/1]	bac	20	`lf:15,ls:5,rf:6,rs:1,a:5`
[3/2]	bba	16	`lf:8,ls:8,rf:2,rs:1,a:1`
[3/3]	cba	16	`lf:16,rf:15,rp:1,rs:4,re:1,a:2`
[3/4]	abb	10	`lf:5,lp:5,a:1`
[3/5]	bab	6	`lf:3,lp:3,rf:4,rp:3,a:5`
[3/6]	aba	6	`lf:3,lp:2,ls:1,rf:1,rs:1,a:5`
[4/0]	acba	22	`lf:14,lp:8,rf:6,rp:3,rs:1,a:2`
[4/1]	cbac	18	`lf:13,ls:5,rf:6,rs:1,a:5`
[4/2]	cbba	8	`lf:4,ls:4,rf:2,rp:1,rs:1,re:1,a:3`
[4/3]	bbba	6	`lf:3,ls:3,a:4`
[4/4]	abbb	6	`lf:3,lp:3,a:4`
[4/5]	bacb	6	`lf:6,rf:2,a:6`
[4/6]	babc	4	`lf:2,lp:2,rf:4,rp:3,rs:2,re:1,lprs:1,a:6`
[5/0]	acbac	22	`lf:12,lp:6,ls:4,rf:5,rp:3,rs:1,re:1,lsrp:1,a:5`
[5/1]	acbba	4	`lf:2,ls:2,rf:1,rp:1,a:6`
[5/2]	cbacb	4	`lf:4,rf:2,a:6`
[5/3]	abacb	4	`lf:2,lp:2,a:7`
[5/4]	cbaab	4	`lf:2,ls:2,rf:5,rs:4,a:2`
[5/5]	acbaa	4	`lf:2,lp:2,a:2`
[5/6]	bacbb	3	`lf:3,rf:1,a:6`

Considering [length 2 / frequency 0] ba=d.

Step 3

Auxiliary generators:
1. c = abba
2. d = ba
Reduction order:
- Right-to-left recursive path with deg(a) = deg(c) = deg(d) = 0, a < c < d; deg(b) = 1

Rewriting system is complete. See ⟨a, b | aabbabaab=ba⟩.