Morphocompletion for #2287 ⟨a, b | aabbbba=baa⟩

Solved by morph:5/2,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: rulesLimit

#	Rule
1.	aabbbba ⇒ baa
2.	aabbbbbaa ⇒ babaa
3.	aabbbbbbaa ⇒ babbaa
4.	aabbbbbabaa ⇒ bababaa
5.	aabbbbbbbaa ⇒ babbbaa
6.	aabbbbbabbaa ⇒ bababbaa
7.	aabbbbbbabaa ⇒ babbabaa
	...

Collecting factors up to length 7 / frequency 3:

[2/0]	bb	32	`lf:32,rf:5`
[2/1]	aa	26	`lf:13,lp:7,ls:6,rf:7,rs:7,lprs:7,lsrs:6`
[2/2]	ba	11	`lf:10,ls:1,rf:16,rp:7,lsrp:1`
[3/0]	bbb	24	`lf:24,rf:1`
[3/1]	aab	14	`lf:7,lp:7`
[3/2]	baa	12	`lf:6,ls:6,rf:7,rp:1,rs:7,re:1,lsrs:6`
[4/0]	bbbb	17	`lf:17`
[4/1]	aabb	14	`lf:7,lp:7`
[4/2]	bbba	8	`lf:7,ls:1,rf:1`
[5/0]	aabbb	14	`lf:7,lp:7`
[5/1]	bbbbb	10	`lf:10,a:1`
[5/2]	bbbba	8	`lf:7,ls:1`
[6/0]	aabbbb	14	`lf:7,lp:7`
[6/1]	bbbbba	6	`lf:6,a:1`
[6/2]	abbbbb	6	`lf:6,a:1`

Considering [length 5 / frequency 2] bbbba=c.

Step 2

Checking up to 20 rules for overlaps.

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

Rewriting system is not complete: roundsLimit

#	Rule
1.	baa ⇒ aac
2.	bca ⇒ cac
3.	babaca ⇒ aabcca
4.	aacccc ⇒ ca
5.	babacca ⇒ aabccca
6.	bcbaca ⇒ cabcca
7.	babbaca ⇒ aabbcca
8.	bbbba ⇒ c
9.	aacacccc ⇒ baca
10.	babaccca ⇒ aabcccca
11.	bcbacca ⇒ cabccca
12.	bababcca ⇒ aabcbcca
13.	babbacca ⇒ aabbccca
14.	bcbbaca ⇒ cabbcca
15.	aaccacccc ⇒ bbaca
16.	cacacccc ⇒ bcca
17.	bcbaccca ⇒ cabcccca
18.	aacccbcca ⇒ cbaca
19.	bcbabcca ⇒ cabcbcca
20.	caccacccc ⇒ bbcca
	...

Collecting factors up to length 6 / frequency 5:

[2/0]	cc	34	`lf:29,ls:5,rf:20,a:3`
[2/1]	ca	34	`lf:19,lp:2,ls:13,rf:23,rp:7,rs:17,re:1,lsrp:15,lprs:2,lsrs:12,a:3`
[2/2]	ba	27	`lf:19,lp:7,ls:1,rf:3,rp:1,a:1`
[2/3]	ac	19	`lf:19,rf:5,rs:2,a:2`
[2/4]	bc	15	`lf:9,lp:6,rf:15,rp:1,a:4`
[3/0]	ccc	18	`lf:13,ls:5,rf:7,a:3`
[3/1]	cca	18	`lf:10,ls:8,rf:13,rs:13,lsrs:7,a:6`
[3/2]	bab	14	`lf:8,lp:6,a:8`
[3/3]	acc	13	`lf:13,a:3`
[3/4]	bcb	10	`lf:5,lp:5,rf:2,a:9`
[4/0]	cccc	10	`lf:5,ls:5,rf:2,a:3`
[4/1]	bcba	8	`lf:4,lp:4,a:9`
[4/2]	accc	8	`lf:8,a:3`
[4/3]	baba	8	`lf:4,lp:4,a:8`
[4/4]	baca	8	`lf:4,ls:4,rf:3,rp:1,rs:3,re:1,a:5`
[5/0]	acccc	10	`lf:5,ls:5,a:3`
[5/1]	bcbac	6	`lf:3,lp:3,a:9`
[5/2]	babac	6	`lf:3,lp:3,a:8`
[5/3]	bacca	6	`lf:3,ls:3,a:11`
[5/4]	caccc	4	`lf:4,a:5`

Considering [length 4 / frequency 0] cccc=d.

Step 3

Checking up to 20 rules for overlaps.

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

Rewriting system is not complete: roundsLimit

#	Rule
1.	ca ⇒ aad
2.	baa ⇒ aac
3.	cda ⇒ daad
4.	dc ⇒ cd
5.	cdda ⇒ ddaad
6.	babada ⇒ aabdaad
7.	aadadadad ⇒ da
8.	cddda ⇒ dddaad
9.	babadda ⇒ aabddaad
10.	bcbada ⇒ aadbdaad
11.	cccc ⇒ d
12.	bbbba ⇒ c
13.	aadaaddadad ⇒ bda
14.	aaaaddadadad ⇒ bada
15.	cdddda ⇒ ddddaad
16.	bcbadda ⇒ aadbddaad
17.	aadadadacd ⇒ dac
18.	cddddda ⇒ dddddaad
19.	aacccbdaad ⇒ cbada
20.	aadadadaccd ⇒ dacc
	...

Collecting factors up to length 6 / frequency 5:

[2/0]	da	34	`lf:25,ls:9,rf:15,rp:4,rs:4,re:1,lsrp:1,a:6`
[2/1]	ad	27	`lf:23,ls:4,rf:14,rs:10,a:5`
[2/2]	aa	18	`lf:11,lp:6,ls:1,rf:15,rp:6,lsrp:10,a:3`
[2/3]	cd	14	`lf:7,lp:5,ls:2,rf:1,rp:1,rs:1,re:1,a:4`
[2/4]	dd	14	`lf:14,rf:12,rp:4,a:8`
[3/0]	ada	17	`lf:15,ls:2,rf:2,rs:2,a:6`
[3/1]	dad	15	`lf:12,ls:3,a:6`
[3/2]	dda	14	`lf:8,ls:6,rf:6,rp:1,lsrp:1,a:8`
[3/3]	aad	12	`lf:7,lp:4,ls:1,rf:12,rp:3,rs:10,re:1,a:5`
[3/4]	cdd	8	`lf:4,lp:4,a:8`
[4/0]	adad	13	`lf:10,ls:3,a:6`
[4/1]	dada	9	`lf:9,a:6`
[4/2]	aada	8	`lf:4,lp:4,a:6`
[4/3]	cddd	6	`lf:3,lp:3,a:9`
[4/4]	ddda	6	`lf:3,ls:3,rf:3,rp:1,lsrp:1,a:9`
[5/0]	dadad	10	`lf:7,ls:3,a:6`
[5/1]	adada	7	`lf:7,a:6`
[5/2]	aadad	6	`lf:3,lp:3,a:6`
[5/3]	cdddd	4	`lf:2,lp:2,a:13`
[5/4]	bcbad	4	`lf:2,lp:2,a:36`

Considering [length 2 / frequency 0] da=e.

Step 4

Auxiliary generators:
1. c = bbbba
2. d = cccc
3. e = da
Reduction order:
- Right-to-left recursive path with deg(a) = 0; deg(e) = 1; deg(d) = deg(c) = deg(b) = 2, d < c < b

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