Morphocompletion for #5657 ⟨a, b | aabaab=abbaa⟩

Solved by morph:4/0,2/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: arenaTotalLimit

#	Rule
1.	abbaa ⇒ aabaab
2.	aabaabbbaa ⇒ aabaababaab
3.	aabaaabaabbbbaa ⇒ aabaaabaabbabaab
4.	aabaababaabbbaa ⇒ aabaababaababaab
5.	aabaaabaababaabbbbaa ⇒ aabaaabaababaabbabaab
6.	aabaababaaabaabbbbaa ⇒ aabaababaaabaabbabaab
	...

Collecting factors up to length 7 / frequency 3:

[2/0]	aa	36	`lf:25,lp:5,ls:6,rf:26,rp:6,lprp:5,lsrp:6`
[2/1]	ab	21	`lf:20,lp:1,rf:31,rs:6,lprs:1`
[2/2]	ba	20	`lf:20,rf:25`
[3/0]	baa	23	`lf:17,ls:6,rf:17`
[3/1]	aab	21	`lf:16,lp:5,rf:23,rp:6,rs:6,lprp:5,lprs:5`
[3/2]	aba	14	`lf:14,rf:22`
[4/0]	aaba	16	`lf:11,lp:5,rf:14,rp:6,lprp:5`
[4/1]	bbaa	12	`lf:6,ls:6`
[4/2]	abaa	11	`lf:11,rf:17`
[5/0]	aabaa	13	`lf:8,lp:5,rf:9,rp:6,lprp:5`
[5/1]	bbbaa	10	`lf:5,ls:5,a:1`
[5/2]	abaab	8	`lf:8,rf:14,rs:6`
[6/0]	aabaab	9	`lf:6,lp:3,rf:7,rp:4,rs:1,re:1,lprp:3`
[6/1]	bbbbaa	6	`lf:3,ls:3,a:2`
[6/2]	baabbb	5	`lf:5,a:1`

Considering [length 4 / frequency 0] aaba=c.

Step 2

Checking up to 20 rules for overlaps.

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

Rewriting system is not complete: roundsLimit

#	Rule
1.	caba ⇒ aabc
2.	aaba ⇒ c
3.	cabba ⇒ abbc
4.	abbcc ⇒ caabcba
5.	cbbac ⇒ cabcba
6.	abbac ⇒ aabcba
7.	cbbca ⇒ aabccab
8.	abbca ⇒ ccab
9.	cbbaa ⇒ aabcab
10.	abbaa ⇒ cab
11.	aabcaabcba ⇒ cbbcc
12.	aabcbbcc ⇒ cabcaabcba
13.	cabbbac ⇒ aabcbcba
14.	cabbbca ⇒ aabcbacab
15.	cabbbaa ⇒ aabcbaab
16.	abbcbbc ⇒ cccabbba
17.	abbabbc ⇒ ccabbba
18.	aabccabbba ⇒ cbbabbc
19.	aabcccabbba ⇒ cbbcbbc
20.	aabcbaabba ⇒ cabbbc
	...

Collecting factors up to length 6 / frequency 5:

[2/0]	ab	28	`lf:22,lp:6,rf:22,rp:1,rs:6,lprs:2`
[2/1]	bb	24	`lf:24,rf:12`
[2/2]	ba	22	`lf:15,ls:7,rf:10,rs:7`
[2/3]	aa	20	`lf:11,lp:6,ls:3,rf:10,rp:7,lsrp:2`
[2/4]	ca	19	`lf:11,lp:5,ls:3,rf:12,rp:5`
[3/0]	abb	20	`lf:14,lp:6,rf:5,rp:1`
[3/1]	bba	15	`lf:11,ls:4,rf:3,rs:2`
[3/2]	aab	14	`lf:8,lp:6,rf:10,rp:7,rs:1,a:1`
[3/3]	cab	12	`lf:7,lp:5,rf:10,rp:4,rs:5,re:1,lprs:1`
[3/4]	bbc	10	`lf:8,ls:2,rf:6,rs:4,a:4`
[4/0]	aabc	11	`lf:6,lp:5,rf:9,rp:7,rs:1,re:1,a:2`
[4/1]	abba	10	`lf:5,lp:3,ls:2`
[4/2]	cabb	10	`lf:6,lp:4,rf:3,rp:1,a:3`
[4/3]	abbc	8	`lf:4,lp:3,ls:1,rf:2,rp:1,rs:2,re:1,a:4`
[4/4]	bbba	6	`lf:4,ls:2,rf:2,rs:2,a:3`
[5/0]	cabbb	8	`lf:5,lp:3,rf:3,rp:1,a:3`
[5/1]	abbba	6	`lf:4,ls:2,rf:2,rs:2,a:3`
[5/2]	aabcb	5	`lf:3,lp:2,rf:6,rp:4,a:3`
[5/3]	aabcc	4	`lf:2,lp:2,rf:1,rp:1,a:9`
[5/4]	bcbbc	3	`lf:2,ls:1,rf:1,rs:1,a:18`

Considering [length 2 / frequency 0] ab=d.

Step 3

Checking up to 20 rules for overlaps.

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

Rewriting system is not complete: roundsLimit

#	Rule
1.	cda ⇒ adc
2.	ada ⇒ c
3.	cb ⇒ add
4.	ab ⇒ d
5.	cdba ⇒ dbc
6.	dbcc ⇒ ccdda
7.	dbac ⇒ cdda
8.	dbca ⇒ ccd
9.	dbaa ⇒ cd
10.	dbcd ⇒ ccdb
11.	dbad ⇒ cdb
12.	cdbbc ⇒ cddadba
13.	ccdbba ⇒ dbdbc
14.	cdbbac ⇒ cddadda
15.	cdbbaa ⇒ cddad
16.	cdbbad ⇒ cddadb
17.	ccdbbbc ⇒ ccdbdadba
18.	cdbbdbc ⇒ cddacdbba
19.	dbdbdbc ⇒ ccddadbba
20.	ccdbbbaa ⇒ ccdbdad
	...

Collecting factors up to length 6 / frequency 5:

[2/0]	db	26	`lf:19,lp:7,rf:12,rp:2,rs:3,lprs:2,a:3`
[2/1]	cd	19	`lf:11,lp:7,ls:1,rf:15,rp:8,rs:2,re:1,lprp:5,a:3`
[2/2]	ba	11	`lf:9,ls:2,rf:4,rs:4,a:3`
[2/3]	bc	11	`lf:7,ls:4,rf:2,rs:2,a:10`
[2/4]	bb	10	`lf:10,rf:2,a:9`
[3/0]	cdb	15	`lf:9,lp:6,rf:5,rp:1,rs:2,re:1,a:7`
[3/1]	dbc	10	`lf:5,lp:3,ls:2,rf:2,rp:1,rs:2,re:1,a:10`
[3/2]	dbb	8	`lf:8,rf:2,a:9`
[3/3]	dba	8	`lf:4,lp:3,ls:1,rf:2,rs:2,a:3`
[3/4]	bba	6	`lf:5,ls:1,rf:2,rs:2,a:9`
[4/0]	cdbb	13	`lf:8,lp:5,rf:1,a:9`
[4/1]	ccdb	6	`lf:3,lp:3,rf:3,rp:3,rs:1,re:1,lprp:2,a:13`
[4/2]	dbba	5	`lf:4,ls:1,rf:2,rs:2,a:9`
[4/3]	bbaa	4	`lf:2,ls:2,a:9`
[4/4]	bdbc	4	`lf:2,ls:2,rf:1,rs:1,a:18`
[5/0]	cdbba	8	`lf:4,lp:3,ls:1,rf:1,rs:1,a:9`
[5/1]	ccdbb	6	`lf:3,lp:3,a:18`
[5/2]	bbbaa	2	`lf:1,ls:1,a:22`
[5/3]	bbdbc	2	`lf:1,ls:1,a:19`
[5/4]	dbbbc	2	`lf:1,ls:1,a:24`

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

Step 4

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

Rewriting system is complete. See ⟨a, b | aabaab=abbaa⟩.