Morphocompletion for #4749 ⟨a, b | aabbbbba=baa⟩

Solved by morph:6/2,5/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.	aabbbbba ⇒ baa
2.	aabbbbbbaa ⇒ babaa
3.	aabbbbbbbaa ⇒ babbaa
4.	aabbbbbbabaa ⇒ bababaa
5.	aabbbbbbbbaa ⇒ babbbaa
6.	aabbbbbbabbaa ⇒ bababbaa
7.	aabbbbbbbabaa ⇒ babbabaa
	...

Collecting factors up to length 7 / frequency 3:

[2/0]	bb	39	`lf:39,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	31	`lf:31,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	24	`lf:24`
[4/1]	aabb	14	`lf:7,lp:7`
[4/2]	bbba	8	`lf:7,ls:1,rf:1`
[5/0]	bbbbb	17	`lf:17`
[5/1]	aabbb	14	`lf:7,lp:7`
[5/2]	bbbba	8	`lf:7,ls:1`
[6/0]	aabbbb	14	`lf:7,lp:7`
[6/1]	bbbbbb	10	`lf:10,a:1`
[6/2]	bbbbba	8	`lf:7,ls:1`

Considering [length 6 / frequency 2] bbbbba=c.

Step 2

Checking up to 20 rules for overlaps.

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

Rewriting system is not complete: roundsLimit

#	Rule
1.	aaccccc ⇒ ca
2.	baa ⇒ aac
3.	bca ⇒ cac
4.	baca ⇒ aacaccccc
5.	bcca ⇒ cacaccccc
6.	bacca ⇒ aacacccccaccccc
7.	bccca ⇒ cacacccccaccccc
8.	baccca ⇒ aacacccccacccccaccccc
9.	bcccca ⇒ cacacccccacccccaccccc
10.	bacccca ⇒ aacacccccacccccacccccaccccc
11.	bccccca ⇒ cacacccccacccccacccccaccccc
12.	baccccca ⇒ aacacccccacccccacccccacccccaccccc
13.	bcccccca ⇒ cacacccccacccccacccccacccccaccccc
14.	bacccccca ⇒ aacacccccacccccacccccacccccacccccaccccc
15.	bccccccca ⇒ cacacccccacccccacccccacccccacccccaccccc
16.	baccccccca ⇒ aacacccccacccccacccccacccccacccccacccccaccccc
17.	bcccccccca ⇒ cacacccccacccccacccccacccccacccccacccccaccccc
18.	bacccccccca ⇒ aacacccccacccccacccccacccccacccccacccccacccccaccccc
19.	bccccccccca ⇒ cacacccccacccccacccccacccccacccccacccccacccccaccccc
20.	bbbbba ⇒ c
	...

Collecting factors up to length 6 / frequency 5:

[2/0]	cc	69	`lf:68,ls:1,rf:288,rs:16,a:3`
[2/1]	ca	34	`lf:17,ls:17,rf:82,rp:10,rs:1,re:1,lsrp:18,a:3`
[2/2]	ba	20	`lf:10,lp:9,ls:1,a:1`
[2/3]	bc	18	`lf:9,lp:9,a:4`
[2/4]	ac	9	`lf:9,rf:90,rs:2,a:2`
[3/0]	ccc	53	`lf:52,ls:1,rf:216,rs:16,a:3`
[3/1]	cca	30	`lf:15,ls:15,rf:56,a:6`
[3/2]	bcc	16	`lf:8,lp:8,a:6`
[3/3]	bac	16	`lf:8,lp:8,a:5`
[3/4]	acc	8	`lf:8,rf:72,a:3`
[4/0]	cccc	39	`lf:38,ls:1,rf:144,rs:16,a:3`
[4/1]	ccca	26	`lf:13,ls:13,rf:56,a:7`
[4/2]	bccc	14	`lf:7,lp:7,a:8`
[4/3]	bacc	14	`lf:7,lp:7,a:7`
[4/4]	accc	7	`lf:7,rf:72,a:3`
[5/0]	ccccc	27	`lf:26,ls:1,rf:72,rs:16,a:3`
[5/1]	cccca	22	`lf:11,ls:11,rf:56,a:7`
[5/2]	bcccc	12	`lf:6,lp:6,a:10`
[5/3]	baccc	12	`lf:6,lp:6,a:9`
[5/4]	acccc	6	`lf:6,rf:72,a:3`

Considering [length 5 / frequency 0] ccccc=d.

Step 3

Checking up to 20 rules for overlaps.

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

Rewriting system is not complete: roundsLimit

#	Rule
1.	ca ⇒ aad
2.	cda ⇒ daad
3.	dc ⇒ cd
4.	cdda ⇒ ddaad
5.	cddda ⇒ dddaad
6.	aadadadadad ⇒ da
7.	cdddda ⇒ ddddaad
8.	ccccc ⇒ d
9.	cddddda ⇒ dddddaad
10.	aadadadadacd ⇒ dac
11.	cdddddda ⇒ ddddddaad
12.	aadadadadaccd ⇒ dacc
13.	cddddddda ⇒ dddddddaad
14.	aadadadadacccd ⇒ daccc
15.	cdddddddda ⇒ ddddddddaad
16.	aadadadadaccccd ⇒ dacccc
17.	baa ⇒ aac
18.	bda ⇒ aadaaddadadad
19.	bada ⇒ aaaaddadadadad
20.	bbbbba ⇒ c
	...

Collecting factors up to length 6 / frequency 5:

[2/0]	da	40	`lf:30,ls:10,rf:21,rp:6,rs:1,re:1,lsrp:1,a:6`
[2/1]	dd	28	`lf:28,rf:30,rp:7,a:8`
[2/2]	cd	24	`lf:12,lp:8,ls:4,rf:1,rp:1,rs:1,re:1,a:4`
[2/3]	ad	23	`lf:22,ls:1,rf:19,rs:11,a:5`
[2/4]	cc	12	`lf:10,lp:1,ls:1,rf:6,rs:3,a:2`
[3/0]	ada	22	`lf:21,ls:1,rf:6,a:6`
[3/1]	ddd	21	`lf:21,rf:21,rp:6,a:9`
[3/2]	dad	17	`lf:16,ls:1,rf:7,rs:2,a:6`
[3/3]	cdd	14	`lf:7,lp:7,a:8`
[3/4]	dda	14	`lf:7,ls:7,rf:9,rp:1,lsrp:1,a:8`
[4/0]	adad	17	`lf:16,ls:1,rf:5,rs:2,a:6`
[4/1]	dddd	15	`lf:15,rf:15,rp:5,a:10`
[4/2]	dada	15	`lf:15,rf:5,a:6`
[4/3]	cddd	12	`lf:6,lp:6,a:9`
[4/4]	ddda	12	`lf:6,ls:6,rf:6,rp:1,lsrp:1,a:9`
[5/0]	adada	15	`lf:15,rf:3,a:6`
[5/1]	dadad	12	`lf:11,ls:1,rf:5,rs:2,a:6`
[5/2]	cdddd	10	`lf:5,lp:5,a:10`
[5/3]	ddddd	10	`lf:10,rf:10,rp:4,a:14`
[5/4]	dddda	10	`lf:5,ls:5,rf:5,rp:1,lsrp:1,a:10`

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

Step 4

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

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