Morphocompletion for #4987 ⟨a, b | aaaabba=baaa⟩

Solved by morph:5/1,3/1,5/0. (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: rulesLimit

#	Rule
1.	aaaabba ⇒ baaa
2.	aaaabbbaaa ⇒ baabaaa
3.	aaaabbbbaaa ⇒ baabbaaa
4.	aaaabbbabaaa ⇒ baababaaa
5.	aaaabbbbbaaa ⇒ baabbbaaa
	...

Collecting factors up to length 7 / frequency 3:

[2/0]	aa	32	`lf:23,lp:5,ls:4,rf:14,rs:5,lprs:5,lsrs:4`
[2/1]	bb	12	`lf:12,rf:3`
[2/2]	ba	7	`lf:6,ls:1,rf:10,rp:5,lsrp:1`
[3/0]	aaa	23	`lf:14,lp:5,ls:4,rf:5,rs:5,lprs:5,lsrs:4`
[3/1]	bbb	7	`lf:7,rf:1,a:1`
[3/2]	bba	6	`lf:5,ls:1,rf:2`
[4/0]	aaaa	10	`lf:5,lp:5`
[4/1]	baaa	8	`lf:4,ls:4,rf:5,rp:1,rs:5,re:1,lsrs:4`
[4/2]	aabb	5	`lf:5,rf:2`
[5/0]	aaaab	10	`lf:5,lp:5`
[5/1]	bbaaa	6	`lf:3,ls:3,rf:2,rs:2,lsrs:2,a:1`
[5/2]	aaabb	5	`lf:5`
[6/0]	aaaabb	10	`lf:5,lp:5`
[6/1]	bbbaaa	6	`lf:3,ls:3,rf:1,rs:1,lsrs:1,a:1`
[6/2]	aaabbb	4	`lf:4,a:1`

Considering [length 5 / frequency 1] bbaaa=c.

Step 2

Checking up to 20 rules for overlaps.

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

Rewriting system is not complete: roundsLimit

#	Rule
1.	bcaa ⇒ cac
2.	baaaaa ⇒ aaaac
3.	baaaac ⇒ caa
4.	aaaabcac ⇒ baacaa
5.	bbaaa ⇒ c
6.	baabaaa ⇒ aaaabc
7.	cabba ⇒ bc
8.	caabbaac ⇒ bbacaa
9.	aaaabba ⇒ baaa
10.	aaaabbc ⇒ baac
11.	caaabba ⇒ baaaabc
12.	aaaacbba ⇒ babaaa
13.	aaaacbbc ⇒ babaac
14.	cacaabba ⇒ bcbaaa
15.	cacaabbc ⇒ bcbaac
16.	bbbaac ⇒ cabbc
17.	bbabaaa ⇒ caabba
18.	bbabaac ⇒ caabbc
19.	aaaabbbc ⇒ baabc
20.	bbbaabc ⇒ cabbbc
	...

Collecting factors up to length 6 / frequency 5:

[2/0]	aa	53	`lf:42,lp:6,ls:5,rf:25,rp:2,rs:6,lsrp:2,lprs:3`
[2/1]	ba	25	`lf:17,lp:3,ls:5,rf:13,rp:7,rs:1,lsrp:3`
[2/2]	bb	23	`lf:18,lp:5,rf:6,rp:1`
[2/3]	ca	14	`lf:9,lp:5,rf:8,rp:6,a:3`
[2/4]	ac	14	`lf:9,ls:5,rf:7,rs:5,a:2`
[3/0]	aaa	31	`lf:21,lp:6,ls:4,rf:9,rp:2,rs:3,lsrp:2,lprs:2`
[3/1]	bba	19	`lf:11,lp:3,ls:5,rf:2,rp:1,rs:1,lprs:1`
[3/2]	baa	13	`lf:10,lp:3,rf:9,rp:5`
[3/3]	aab	10	`lf:10,rf:5`
[3/4]	aac	10	`lf:6,ls:4,rf:5,rs:4,a:2`
[4/0]	aaaa	16	`lf:9,lp:6,ls:1,rf:3,rp:2,lsrp:1`
[4/1]	baaa	10	`lf:5,lp:2,ls:3,rf:4,rp:2,rs:3,re:1`
[4/2]	abba	9	`lf:5,ls:4,rf:1,rs:1`
[4/3]	aabb	7	`lf:7,rf:2`
[4/4]	baac	6	`lf:3,ls:3,rf:4,rp:2,rs:3,re:1,a:17`
[5/0]	aaaab	8	`lf:4,lp:4,rf:2,rp:1`
[5/1]	aabba	7	`lf:4,ls:3,rf:1,rs:1`
[5/2]	aaaac	6	`lf:3,lp:2,ls:1,rf:1,rp:1,rs:1,re:1,a:2`
[5/3]	bbaba	4	`lf:2,lp:2,a:4`
[5/4]	bbbaa	4	`lf:2,lp:2,a:19`

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

Step 3

Checking up to 20 rules for overlaps.

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

Rewriting system is not complete: roundsLimit

#	Rule
1.	daa ⇒ c
2.	caadac ⇒ dcaa
3.	aaaadac ⇒ caa
4.	caaadac ⇒ dacaa
5.	caadad ⇒ dc
6.	aaaadad ⇒ c
7.	caaadad ⇒ dac
8.	bc ⇒ cad
9.	bac ⇒ aaaacdad
10.	baaa ⇒ aaaad
11.	baac ⇒ aaaacadad
12.	bdc ⇒ cacdad
13.	bdac ⇒ cacadad
14.	badc ⇒ aaaacdacdad
15.	badac ⇒ aaaacdacadad
16.	baadc ⇒ aaaacadacdad
17.	bddc ⇒ cacdacdad
18.	bddac ⇒ cacdacadad
19.	bdadc ⇒ cacadacdad
20.	bba ⇒ d
	...

Collecting factors up to length 6 / frequency 5:

[2/0]	aa	21	`lf:17,lp:2,ls:2,rf:21,rp:6,rs:3,lsrp:1,lprs:1,a:3`
[2/1]	ad	16	`lf:13,ls:3,rf:18,rs:12,a:3`
[2/2]	ac	16	`lf:8,ls:8,rf:18,rs:1,a:8`
[2/3]	ba	14	`lf:7,lp:6,ls:1,a:2`
[2/4]	da	12	`lf:11,lp:1,rf:18,rp:2,a:4`
[3/0]	dac	12	`lf:6,ls:6,rf:8,rp:2,rs:1,re:1,lsrp:1,a:11`
[3/1]	aaa	10	`lf:7,lp:2,ls:1,rf:12,rp:6,lsrp:1,a:3`
[3/2]	caa	8	`lf:4,lp:4,rf:3,rp:1,rs:3,re:1,lprs:2,a:10`
[3/3]	dad	7	`lf:4,ls:3,rf:10,rs:10,a:5`
[3/4]	aad	7	`lf:7,rf:1,rs:1,a:3`
[4/0]	adac	8	`lf:4,ls:4,rf:2,a:12`
[4/1]	adad	6	`lf:3,ls:3,rf:4,rs:4,a:5`
[4/2]	aada	6	`lf:6,a:5`
[4/3]	caad	4	`lf:2,lp:2,a:10`
[4/4]	aaad	4	`lf:4,rf:1,rs:1,a:3`
[5/0]	aadad	6	`lf:3,ls:3,a:5`
[5/1]	aadac	6	`lf:3,ls:3,a:12`
[5/2]	caaad	4	`lf:2,lp:2,a:11`
[5/3]	aaaad	4	`lf:2,lp:2,rf:1,rp:1,rs:1,re:1,a:3`
[5/4]	caada	4	`lf:2,lp:2,a:10`

Considering [length 5 / frequency 0] aadad=e.

Step 4

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

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