Morphocompletion for #3802 ⟨a, b | abbaaabaab=b⟩

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

Step 1

Checking up to 20 rules for overlaps.

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

Rewriting system is not complete: rulesLimit

#	Rule
1.	aabbbb ⇒ abbbab
2.	bbaaabb ⇒ aabbbab
3.	aabbbabb ⇒ baabbbab
4.	aaabbb ⇒ baaabb
5.	abbaaabab ⇒ bbaaabaab
6.	abbaaabaab ⇒ b
7.	bbaaababaaabb ⇒ abbb
8.	bbaaababaaabab ⇒ abbab
9.	bbaaabaabaaabb ⇒ aabbb
	...

Collecting factors up to length 8 / frequency 7:

[2/0]	aa	27	`lf:24,lp:3,rf:8,rp:2`
[2/1]	bb	27	`lf:17,lp:4,ls:6,rf:13,rp:1,rs:3,lprs:2,lsrs:3`
[2/2]	ab	26	`lf:21,lp:2,ls:3,rf:13,rp:3,rs:5,lsrp:1,lprs:1,lsrs:2`
[2/3]	ba	16	`lf:16,rf:8,rp:2`
[3/0]	aab	17	`lf:14,lp:2,ls:1,rf:6,rp:2,rs:1`
[3/1]	abb	15	`lf:9,lp:2,ls:4,rf:7,rp:3,rs:1,lsrp:1`
[3/2]	aaa	11	`lf:10,lp:1,rf:2`
[3/3]	baa	11	`lf:11,rf:4,rp:2`
[3/4]	bba	11	`lf:7,lp:4,rf:5,rp:1`
[3/5]	aba	9	`lf:9,rf:1`
[3/6]	bab	7	`lf:5,ls:2,rf:4,rs:4,lsrs:1,a:1`
[4/0]	aaab	11	`lf:10,lp:1,rf:2`
[4/1]	aabb	11	`lf:6,lp:2,ls:3,rf:4,rp:2,rs:1,lsrp:2,a:5`
[4/2]	bbaa	10	`lf:6,lp:4,rf:1,rp:1`
[4/3]	baaa	9	`lf:9,rf:2,rp:1`
[4/4]	aaba	7	`lf:7,rf:1`
[4/5]	abab	6	`lf:4,ls:2,a:1`
[4/6]	abaa	5	`lf:5,rf:1`
[5/0]	bbaaa	10	`lf:6,lp:4,rf:1,rp:1`
[5/1]	baaab	9	`lf:9,rf:2,rp:1`
[5/2]	aaabb	8	`lf:4,lp:1,ls:3,rf:1,rs:1,lprs:10,a:5`
[5/3]	aaaba	6	`lf:6,rf:1`
[5/4]	aabab	6	`lf:4,ls:2,a:1`
[5/5]	aabbb	6	`lf:3,lp:2,ls:1,rf:3,rp:2,rs:1,re:1,a:6`
[5/6]	abbaa	4	`lf:2,lp:2`
[6/0]	bbaaab	10	`lf:6,lp:4,rf:1,rp:1`
[6/1]	aaabab	6	`lf:4,ls:2,a:1`
[6/2]	baaaba	6	`lf:6,rf:1`
[6/3]	baaabb	6	`lf:3,ls:3,rf:1,rp:1,rs:1,re:1,a:5`
[6/4]	abbaaa	4	`lf:2,lp:2`
[6/5]	aabaab	3	`lf:2,ls:1,rf:1,rs:1`
[6/6]	abaaab	3	`lf:3,a:4`
[7/0]	bbaaaba	8	`lf:5,lp:3,rf:1,rp:1`
[7/1]	baaabab	6	`lf:4,ls:2,a:1`
[7/2]	abaaabb	4	`lf:2,ls:2,a:5`
[7/3]	abbaaab	4	`lf:2,lp:2`
[7/4]	aaabaab	3	`lf:2,ls:1,rf:1,rs:1`
[7/5]	aaababa	2	`lf:2,a:4`
[7/6]	aababaa	2	`lf:2,a:4`

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

Step 2

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

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