Morphocompletion for #4675 ⟨a, b | aababbba=baa⟩

Solved by morph:6/1,3/0,3/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.	aababbba ⇒ baa
2.	aababbbbaa ⇒ babaa
3.	aababbbbbaa ⇒ babbaa
4.	aababbbbabaa ⇒ bababaa
5.	aababbbbbbaa ⇒ babbbaa
6.	aababbbbabbaa ⇒ bababbaa
7.	aababbbbbabaa ⇒ babbabaa
	...

Collecting factors up to length 7 / frequency 3:

[2/0]	aa	26	`lf:13,lp:7,ls:6,rf:7,rs:7,lprs:7,lsrs:6`
[2/1]	bb	25	`lf:25,rf:5`
[2/2]	ba	18	`lf:17,ls:1,rf:16,rp:7,lsrp:1`
[3/0]	bbb	17	`lf:17,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]	aaba	14	`lf:7,lp:7`
[4/1]	bbbb	10	`lf:10,a:1`
[4/2]	bbba	8	`lf:7,ls:1,rf:1`
[5/0]	aabab	14	`lf:7,lp:7`
[5/1]	babbb	7	`lf:7,rf:1,rp:1`
[5/2]	ababb	7	`lf:7,rf:1`
[6/0]	aababb	14	`lf:7,lp:7`
[6/1]	ababbb	7	`lf:7`
[6/2]	babbbb	6	`lf:6,a:1`

Considering [length 6 / frequency 1] ababbb=c.

Step 2

Checking up to 20 rules for overlaps.

Auxiliary generators:
1. c = ababbb
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.	aacaccca ⇒ caa
2.	aacacccc ⇒ cac
3.	baa ⇒ aca
4.	bac ⇒ acc
5.	bcaa ⇒ acacaccca
6.	bcac ⇒ acacacccc
7.	bccaa ⇒ acacacccacaccca
8.	bccac ⇒ acacacccacacccc
9.	bcccaa ⇒ acacacccacacccacaccca
10.	bcccac ⇒ acacacccacacccacacccc
11.	bccccaa ⇒ acacacccacacccacacccacaccca
12.	bccccac ⇒ acacacccacacccacacccacacccc
13.	bcccccaa ⇒ acacacccacacccacacccacacccacaccca
14.	bcccccac ⇒ acacacccacacccacacccacacccacacccc
15.	bccccccaa ⇒ acacacccacacccacacccacacccacacccacaccca
16.	bccccccac ⇒ acacacccacacccacacccacacccacacccacacccc
17.	bcccccccaa ⇒ acacacccacacccacacccacacccacacccacacccacaccca
18.	bcccccccac ⇒ acacacccacacccacacccacacccacacccacacccacacccc
19.	bccccccccaa ⇒ acacacccacacccacacccacacccacacccacacccacacccacaccca
20.	ababbb ⇒ c
	...

Collecting factors up to length 6 / frequency 5:

[2/0]	cc	55	`lf:54,ls:1,rf:136,rs:8,a:3`
[2/1]	bc	30	`lf:15,lp:15,a:6`
[2/2]	aa	22	`lf:11,lp:2,ls:9,rf:1,rs:1,lprs:1,a:2`
[2/3]	ac	20	`lf:12,ls:8,rf:146,rp:17,rs:1,lsrp:17,a:2`
[2/4]	ca	19	`lf:18,ls:1,rf:139,rp:2,rs:9,lsrp:1,a:2`
[3/0]	ccc	40	`lf:39,ls:1,rf:71,rs:7,a:3`
[3/1]	bcc	26	`lf:13,lp:13,a:8`
[3/2]	cac	16	`lf:9,ls:7,rf:129,rp:1,rs:1,re:1,a:3`
[3/3]	caa	16	`lf:8,ls:8,rf:1,rp:1,rs:1,re:1,a:3`
[3/4]	cca	15	`lf:14,ls:1,rf:57,rs:8,a:3`
[4/0]	cccc	27	`lf:26,ls:1,rf:7,rs:7,a:5`
[4/1]	bccc	22	`lf:11,lp:11,a:10`
[4/2]	ccaa	14	`lf:7,ls:7,a:8`
[4/3]	ccca	13	`lf:12,ls:1,rf:57,rs:8,a:3`
[4/4]	ccac	12	`lf:6,ls:6,rf:49,a:8`
[5/0]	bcccc	18	`lf:9,lp:9,a:12`
[5/1]	ccccc	16	`lf:16,a:14`
[5/2]	cccaa	12	`lf:6,ls:6,a:10`
[5/3]	cccac	10	`lf:5,ls:5,rf:49,a:8`
[5/4]	cccca	9	`lf:9,a:12`

Considering [length 3 / frequency 0] ccc=d.

Step 3

Checking up to 20 rules for overlaps.

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

Rewriting system is not complete: roundsLimit

#	Rule
1.	cd ⇒ dc
2.	aacada ⇒ caa
3.	aacadd ⇒ cad
4.	aacadc ⇒ cac
5.	ccc ⇒ d
6.	baa ⇒ aca
7.	bad ⇒ adc
8.	bdaa ⇒ acacadacadacada
9.	bdad ⇒ acacadacadacadd
10.	bac ⇒ acc
11.	bdac ⇒ acacadacadacadc
12.	bcaa ⇒ acacada
13.	bdcaa ⇒ acacadacadacadacada
14.	bcad ⇒ acacadd
15.	bdcad ⇒ acacadacadacadacadd
16.	bcac ⇒ acacadc
17.	bccaa ⇒ acacadacada
18.	bccad ⇒ acacadacadd
19.	bccac ⇒ acacadacadc
20.	ababbb ⇒ c
	...

Collecting factors up to length 6 / frequency 5:

[2/0]	aa	16	`lf:8,lp:3,ls:5,rf:1,rs:1,lprs:1,a:3`
[2/1]	ad	13	`lf:8,ls:5,rf:28,rp:1,rs:1,lsrp:10,a:7`
[2/2]	bc	12	`lf:6,lp:6,a:9`
[2/3]	ca	11	`lf:11,rf:41,rp:3,rs:1,a:3`
[2/4]	ac	11	`lf:7,ls:4,rf:40,rp:13,rs:1,lsrp:13,a:3`
[3/0]	cad	9	`lf:6,ls:3,rf:27,rp:1,rs:1,re:1,a:7`
[3/1]	bcc	6	`lf:3,lp:3,a:14`
[3/2]	bca	6	`lf:3,lp:3,a:9`
[3/3]	bda	6	`lf:3,lp:3,a:17`
[3/4]	caa	6	`lf:3,ls:3,rf:1,rp:1,rs:1,re:1,a:12`
[4/0]	bcca	6	`lf:3,lp:3,a:14`
[4/1]	aaca	6	`lf:3,lp:3,a:7`
[4/2]	bdca	4	`lf:2,lp:2,a:21`
[4/3]	acad	3	`lf:3,rf:26,a:7`
[4/4]	abbb	2	`lf:1,ls:1,a:1`
[5/0]	aacad	6	`lf:3,lp:3,a:7`
[5/1]	babbb	2	`lf:1,ls:1,a:1`
[5/2]	ababb	2	`lf:1,lp:1,a:1`
[5/3]	acadc	2	`lf:1,ls:1,rf:3,rs:3,a:7`
[5/4]	acadd	2	`lf:1,ls:1,rf:4,rs:4,a:10`

Considering [length 3 / frequency 0] cad=e.

Step 4

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

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