Morphocompletion for #5045 ⟨a, b | aaababa=baaa⟩

Solved by morph:3/2,4/2,4/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.	aaababa ⇒ baaa
2.	aaababbaaa ⇒ baabaaa
3.	aaababbbaaa ⇒ baabbaaa
4.	aaababbabaaa ⇒ baababaaa
5.	aaababbbbaaa ⇒ baabbbaaa
	...

Collecting factors up to length 7 / frequency 3:

[2/0]	aa	27	`lf:18,lp:5,ls:4,rf:14,rs:5,lprs:5,lsrs:4`
[2/1]	ba	12	`lf:11,ls:1,rf:10,rp:5,lsrp:1`
[2/2]	ab	11	`lf:11,rf:5`
[3/0]	aaa	18	`lf:9,lp:5,ls:4,rf:5,rs:5,lprs:5,lsrs:4`
[3/1]	aba	8	`lf:7,ls:1,rf:3`
[3/2]	bab	6	`lf:6,rf:1`
[4/0]	aaab	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]	abab	5	`lf:5,rf:1`
[5/0]	aaaba	10	`lf:5,lp:5`
[5/1]	bbaaa	6	`lf:3,ls:3,rf:2,rs:2,lsrs:2,a:1`
[5/2]	aabab	5	`lf:5,rf:1`
[6/0]	aaabab	10	`lf:5,lp:5`
[6/1]	bbbaaa	4	`lf:2,ls:2,rf:1,rs:1,lsrs:1,a:3`
[6/2]	aababb	4	`lf:4,a:1`

Considering [length 3 / frequency 2] bab=c.

Step 2

Checking up to 20 rules for overlaps.

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

Rewriting system is not complete: pendingRulesLimit

#	Rule
1.	aaacaaca ⇒ caaa
2.	aaacaaccaaa ⇒ caacaaa
3.	aaacaacccaaa ⇒ caaccaaa
4.	baaa ⇒ aaaca
5.	bac ⇒ cab
6.	bcaaa ⇒ aaacacaaca
7.	baacaaa ⇒ aaaccaaa
8.	bccaaa ⇒ aaacacaacacaaca
9.	baaccaaa ⇒ aaacccaaa
10.	baacacaaa ⇒ aaaccacaaa
11.	bcaacaaa ⇒ aaacacaaccaaa
12.	baacaacaaa ⇒ aaaccaacaaa
13.	baacccaaa ⇒ aaaccccaaa
14.	bab ⇒ c
	...

Collecting factors up to length 6 / frequency 5:

[2/0]	aa	52	`lf:38,lp:3,ls:11,rf:43,rp:9,rs:9,lsrp:9,lprs:3,lsrs:8,a:2`
[2/1]	ca	18	`lf:17,ls:1,rf:25,rp:4,rs:3,lsrp:1,a:2`
[2/2]	ba	16	`lf:8,lp:8,a:1`
[2/3]	ac	16	`lf:15,ls:1,rf:21,a:2`
[2/4]	cc	7	`lf:7,rf:10,a:6`
[3/0]	aaa	28	`lf:14,lp:3,ls:11,rf:18,rp:9,rs:9,lsrp:9,lprs:3,lsrs:8,a:2`
[3/1]	caa	15	`lf:15,rf:16,rp:3,a:4`
[3/2]	aac	13	`lf:13,rf:16,a:2`
[3/3]	baa	12	`lf:6,lp:6,a:2`
[3/4]	aca	11	`lf:10,ls:1,rf:14,rs:3,a:2`
[4/0]	caaa	20	`lf:10,ls:10,rf:9,rp:1,rs:9,re:1,lsrs:8,a:4`
[4/1]	baac	10	`lf:5,lp:5,a:6`
[4/2]	aaca	10	`lf:9,ls:1,rf:9,rs:3,a:2`
[4/3]	acaa	8	`lf:8,rf:7,a:4`
[4/4]	aaac	6	`lf:3,lp:3,rf:9,rp:9,a:2`
[5/0]	ccaaa	10	`lf:5,ls:5,rf:5,rs:5,lsrs:3,a:6`
[5/1]	acaaa	8	`lf:4,ls:4,rf:3,rs:3,lsrs:2,a:6`
[5/2]	aacaa	7	`lf:7,rf:2,a:4`
[5/3]	baaca	6	`lf:3,lp:3,a:6`
[5/4]	aaaca	6	`lf:3,lp:3,rf:4,rp:4,rs:1,re:1,a:2`

Considering [length 4 / frequency 2] aaca=d.

Step 3

Checking up to 20 rules for overlaps.

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

Rewriting system is not complete: roundsLimit

#	Rule
1.	aaadacd ⇒ dad
2.	aaaaacd ⇒ daa
3.	daca ⇒ aacd
4.	aaca ⇒ d
5.	aacdad ⇒ daadacd
6.	caad ⇒ adacd
7.	aacdaa ⇒ daaaacd
8.	caaa ⇒ aaacd
9.	aaacddacd ⇒ cdad
10.	aaacdca ⇒ cad
11.	aaacdcdca ⇒ ccad
12.	bdd ⇒ adaacdca
13.	bad ⇒ adca
14.	bdad ⇒ addacd
15.	baad ⇒ aaacd
16.	bdaa ⇒ adaacd
17.	baaa ⇒ ad
18.	bac ⇒ cab
19.	bcad ⇒ adcdca
20.	bab ⇒ c
	...

Collecting factors up to length 6 / frequency 5:

[2/0]	aa	35	`lf:23,lp:8,ls:4,rf:12,rp:3,rs:1,lsrp:1,lprs:1,a:2`
[2/1]	ca	13	`lf:7,lp:2,ls:4,rf:6,rp:2,rs:3,lsrp:1,a:2`
[2/2]	ad	13	`lf:7,ls:6,rf:12,rp:7,rs:5,re:1,lsrp:4,a:3`
[2/3]	cd	12	`lf:9,ls:3,rf:11,rp:1,rs:8,lsrp:1,a:5`
[2/4]	ac	12	`lf:11,ls:1,rf:9,a:2`
[3/0]	aaa	16	`lf:9,lp:5,ls:2,rf:4,rp:2,lsrp:1,a:3`
[3/1]	acd	11	`lf:8,ls:3,rf:9,rs:8,a:5`
[3/2]	aac	10	`lf:7,lp:3,rf:6,rp:1,a:2`
[3/3]	aad	5	`lf:3,ls:2,rf:1,a:6`
[3/4]	baa	4	`lf:2,lp:2,a:3`
[4/0]	aacd	9	`lf:6,lp:2,ls:1,rf:6,rp:1,rs:5,re:1,lprs:1,a:5`
[4/1]	aaac	7	`lf:4,lp:3,rf:3,rp:2,a:6`
[4/2]	cdca	4	`lf:2,ls:2,rf:2,rs:2,a:9`
[4/3]	dacd	4	`lf:2,ls:2,rf:3,rs:3,a:10`
[4/4]	aaaa	3	`lf:2,lp:1,rf:1,a:13`
[5/0]	aaacd	8	`lf:4,lp:3,ls:1,rf:3,rp:2,rs:3,re:2,a:6`
[5/1]	aacda	4	`lf:2,lp:2,a:12`
[5/2]	acdca	2	`lf:1,ls:1,rf:1,rs:1,a:9`
[5/3]	dcdca	2	`lf:1,ls:1,rf:1,rs:1,a:21`
[5/4]	aacdc	2	`lf:2,rf:1,a:9`

Considering [length 4 / frequency 0] aacd=e.

Step 4

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

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