Morphocompletion for #4277 ⟨a, b | abaabbaba=ba⟩

Solved by morph:3/1. (See Morphocompletion.)

Step 1

Checking up to 20 rules for overlaps.

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

Rewriting system is not complete: roundsLimit

#	Rule
1.	abaabbba ⇒ baabbaba
2.	abaabbaba ⇒ ba
3.	abaabbbba ⇒ baabbabba
4.	abaabbabba ⇒ bba
5.	abaabbbbba ⇒ baabbabbba
6.	abaabbabbba ⇒ bbba
7.	abaabbbbbba ⇒ baabbabbbba
8.	abaabbabbbba ⇒ bbbba
9.	abaabbbbbbba ⇒ baabbabbbbba
10.	abaabbabbbbba ⇒ bbbbba
11.	abaabbbbbbbba ⇒ baabbabbbbbba
12.	abaabbabbbbbba ⇒ bbbbbba
13.	abaabbbbbbbbba ⇒ baabbabbbbbbba
14.	abaabbabbbbbbba ⇒ bbbbbbba
15.	abaabbbbbbbbbba ⇒ baabbabbbbbbbba
16.	abaabbabbbbbbbba ⇒ bbbbbbbba
17.	abaabbbbbbbbbbba ⇒ baabbabbbbbbbbba
18.	abaabbabbbbbbbbba ⇒ bbbbbbbbba
19.	abaabbabbbbbbbbbba ⇒ bbbbbbbbbba
20.	abaabbabbbbbbbbbbba ⇒ bbbbbbbbbbba
	...

Collecting factors up to length 8 / frequency 7:

[2/0]	bb	120	`lf:120,rf:100,rp:10`
[2/1]	ab	71	`lf:51,lp:20,rf:18`
[2/2]	ba	71	`lf:51,ls:20,rf:38,rp:10,rs:20,re:1,lsrp:10,lsrs:20`
[2/3]	aa	20	`lf:20,rf:9`
[3/0]	bbb	90	`lf:90,rf:73,rp:9,a:1`
[3/1]	bba	49	`lf:30,ls:19,rf:27,rp:1,rs:18,re:1,lsrp:1,lsrs:18`
[3/2]	aba	42	`lf:21,lp:20,ls:1,rf:1,rs:1,lprs:1`
[3/3]	abb	30	`lf:30,rf:17`
[3/4]	aab	20	`lf:20,rf:9`
[3/5]	baa	20	`lf:20,rf:9,rp:9`
[3/6]	bab	11	`lf:11,rf:9`
[4/0]	bbbb	72	`lf:72,rf:57,rp:8,a:3`
[4/1]	abaa	40	`lf:20,lp:20`
[4/2]	bbba	36	`lf:18,ls:18,rf:16,rp:1,rs:16,re:1,lsrp:1,lsrs:16,a:1`
[4/3]	aabb	20	`lf:20,rf:9`
[4/4]	baab	20	`lf:20,rf:9,rp:9`
[4/5]	abbb	18	`lf:18,rf:7,a:1`
[4/6]	abba	13	`lf:12,ls:1,rf:10,rs:1`
[5/0]	bbbbb	56	`lf:56,rf:43,rp:7,a:6`
[5/1]	abaab	40	`lf:20,lp:20`
[5/2]	bbbba	32	`lf:16,ls:16,rf:14,rp:1,rs:14,re:1,lsrp:1,lsrs:14,a:3`
[5/3]	baabb	20	`lf:20,rf:9,rp:9`
[5/4]	abbbb	16	`lf:16,rf:6,a:3`
[5/5]	abbab	11	`lf:11,rf:9`
[5/6]	aabba	11	`lf:11,rf:9`
[6/0]	bbbbbb	42	`lf:42,rf:31,rp:6,a:8`
[6/1]	abaabb	40	`lf:20,lp:20`
[6/2]	bbbbba	28	`lf:14,ls:14,rf:12,rp:1,rs:12,re:1,lsrp:1,lsrs:12,a:6`
[6/3]	abbbbb	14	`lf:14,rf:5,a:6`
[6/4]	aabbab	11	`lf:11,rf:9`
[6/5]	baabba	11	`lf:11,rf:9,rp:9`
[6/6]	abbabb	10	`lf:10,rf:8,a:2`
[7/0]	bbbbbbb	30	`lf:30,rf:21,rp:5,a:10`
[7/1]	bbbbbba	24	`lf:12,ls:12,rf:10,rp:1,rs:10,re:1,lsrp:1,lsrs:10,a:8`
[7/2]	abaabba	22	`lf:11,lp:11`
[7/3]	abaabbb	18	`lf:9,lp:9,a:1`
[7/4]	abbbbbb	12	`lf:12,rf:4,a:8`
[7/5]	baabbab	11	`lf:11,rf:9,rp:9`
[7/6]	aabbabb	10	`lf:10,rf:8,a:2`

Considering [length 3 / frequency 1] bba=c.

Step 2

Auxiliary generators:
1. c = bba
Reduction order:
- Left-to-right recursive path with deg(a) = deg(c) = 0, a < c; deg(b) = 1

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