Morphocompletion for #5827 ⟨a, b | abaaab=baaba⟩

Solved by morph:3/2,2/2,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: roundsLimit

#	Rule
1.	baaba ⇒ abaaab
2.	abaaababa ⇒ baaabaaab
3.	abaaaabaaabba ⇒ babaaabaaab
4.	abaaabaaabaaabba ⇒ bababaaabaaab
5.	abaaabbaaababa ⇒ baabbaaabaaab
6.	abaaaabaaaabaaabaabba ⇒ babababaaabaaab
7.	abaaabbaaaabaaabba ⇒ baabbabaaabaaab
8.	abaaabaabbaaababa ⇒ babaabbaaabaaab
9.	abaaabaaabaaaabaaabaabba ⇒ bababababaaabaaab
10.	abaaabbaaabaaabaaabba ⇒ baabbababaaabaaab
11.	abaaabaabbaaaabaaabba ⇒ babaabbabaaabaaab
12.	abaaaabaaababbaaababa ⇒ bababaabbaaabaaab
13.	abaaabbaaabbaaababa ⇒ baabbaabbaaabaaab
14.	abaaabbaaaabaaaabaaabaabba ⇒ baabbabababaaabaaab
15.	abaaabaabbaaabaaabaaabba ⇒ babaabbababaaabaaab
16.	abaaaabaaababbaaaabaaabba ⇒ bababaabbabaaabaaab
17.	abaaabbaaabbaaaabaaabba ⇒ baabbaabbabaaabaaab
18.	abaaabaaabaaababbaaababa ⇒ babababaabbaaabaaab
19.	abaaabbaaabaabbaaababa ⇒ baabbabaabbaaabaaab
20.	abaaabaabbaaabbaaababa ⇒ babaabbaabbaaabaaab
	...

Collecting factors up to length 7 / frequency 3:

[2/0]	aa	139	`lf:139,rf:96`
[2/1]	ba	120	`lf:99,lp:1,ls:20,rf:90,rp:19,lsrp:19`
[2/2]	ab	117	`lf:98,lp:19,rf:91,rp:1,rs:20,lprs:19`
[3/0]	aba	97	`lf:69,lp:19,ls:9,rf:53,rp:1,lsrp:1`
[3/1]	aaa	71	`lf:71,rf:39`
[3/2]	baa	69	`lf:68,lp:1,rf:57,rp:8`
[4/0]	abaa	68	`lf:49,lp:19,rf:39,rp:1`
[4/1]	baaa	59	`lf:59,rf:39,rp:1`
[4/2]	aaab	59	`lf:59,rf:39,rs:20`
[5/0]	abaaa	60	`lf:41,lp:19,rf:31,rp:1`
[5/1]	baaab	47	`lf:47,rf:39,rp:1,rs:20`
[5/2]	aaaba	41	`lf:41,rf:19,a:1`
[6/0]	abaaab	49	`lf:34,lp:15,rf:31,rp:1,rs:20,re:1,lprs:15`
[6/1]	aaabaa	30	`lf:30,rf:19,a:1`
[6/2]	baaaba	29	`lf:29,rf:19,rp:1,a:1`

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

Step 2

Checking up to 20 rules for overlaps.

Auxiliary generators:
1. c = baa
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 ⇒ c
2.	cca ⇒ acac
3.	cba ⇒ acab
4.	acaba ⇒ cc
5.	acaacab ⇒ bacc
6.	acacacab ⇒ babacc
7.	acabcaba ⇒ cbcc
8.	acaacaacacb ⇒ bababacc
9.	acabcaacab ⇒ cbbacc
10.	acacbcaba ⇒ bacbcc
11.	acacacaacacb ⇒ babababacc
12.	acabcacacab ⇒ cbbabacc
13.	acacbcaacab ⇒ bacbbacc
14.	acaccbcaba ⇒ babacbcc
15.	acabcabcaba ⇒ cbcbcc
16.	acacbcacacab ⇒ bacbbabacc
17.	acabcabcaacab ⇒ cbcbbacc
18.	acacccbcaba ⇒ bababacbcc
19.	acabcacbcaba ⇒ cbbacbcc
20.	acacbcabcaba ⇒ bacbcbcc
	...

Collecting factors up to length 6 / frequency 5:

[2/0]	ac	58	`lf:41,lp:17,rf:19,rp:2,rs:1,a:2`
[2/1]	ca	50	`lf:49,ls:1,rf:2,a:2`
[2/2]	ab	31	`lf:24,ls:7,rf:12,rs:1,a:2`
[2/3]	ba	20	`lf:10,lp:1,ls:9,rf:27,rp:10,lsrp:4,a:1`
[2/4]	bc	16	`lf:16,rf:10,a:5`
[3/0]	aca	49	`lf:32,lp:17,rf:2,rp:2,a:2`
[3/1]	cab	31	`lf:24,ls:7,rf:1,rs:1,a:2`
[3/2]	cac	17	`lf:17,rf:1,rs:1,a:6`
[3/3]	bca	16	`lf:16,a:5`
[3/4]	aba	16	`lf:8,ls:8,rf:11,a:3`
[4/0]	acab	28	`lf:14,lp:7,ls:7,rf:1,rp:1,rs:1,re:1,a:2`
[4/1]	acac	22	`lf:14,lp:8,rf:1,rp:1,rs:1,re:1,a:6`
[4/2]	caba	16	`lf:8,ls:8,a:3`
[4/3]	bcab	10	`lf:10,a:5`
[4/4]	cacb	9	`lf:7,ls:2,a:11`
[5/0]	bcaba	14	`lf:7,ls:7,a:5`
[5/1]	acacb	12	`lf:6,lp:4,ls:2,a:11`
[5/2]	acabc	12	`lf:6,lp:6,a:5`
[5/3]	cabca	9	`lf:9,a:5`
[5/4]	aacab	8	`lf:4,ls:4,a:4`

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

Step 3

Checking up to 20 rules for overlaps.

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

Rewriting system is not complete: roundsLimit

#	Rule
1.	daa ⇒ ac
2.	ab ⇒ d
3.	baa ⇒ c
4.	cca ⇒ acac
5.	acda ⇒ cc
6.	dada ⇒ aacd
7.	bada ⇒ acd
8.	cb ⇒ bad
9.	acaacd ⇒ bacc
10.	ccda ⇒ bacc
11.	acdda ⇒ cacd
12.	acdb ⇒ badd
13.	acacacd ⇒ bdacc
14.	acdcda ⇒ badcc
15.	ccdda ⇒ bacacd
16.	ccdb ⇒ bdadd
17.	ccdcda ⇒ bdadcc
18.	acdcdda ⇒ badcacd
19.	acdcdb ⇒ badbadd
20.	ccdcdb ⇒ bdadbadd
	...

Collecting factors up to length 6 / frequency 5:

[2/0]	da	22	`lf:11,lp:2,ls:9,rf:4,a:3`
[2/1]	cd	20	`lf:18,ls:2,rf:5,rs:5,a:3`
[2/2]	ac	19	`lf:11,lp:8,rf:12,rp:3,rs:2,re:1,a:3`
[2/3]	cc	12	`lf:6,lp:6,rf:6,rp:1,rs:6,re:1,lprs:2,a:8`
[2/4]	db	8	`lf:4,ls:4,rf:2,a:7`
[3/0]	acd	16	`lf:8,lp:6,ls:2,rf:5,rp:1,rs:5,re:1,lprs:2,a:3`
[3/1]	ccd	10	`lf:5,lp:5,a:10`
[3/2]	cdb	8	`lf:4,ls:4,a:7`
[3/3]	cda	8	`lf:4,ls:4,a:8`
[3/4]	dda	6	`lf:3,ls:3,a:9`
[4/0]	cdda	6	`lf:3,ls:3,a:9`
[4/1]	acdc	6	`lf:3,lp:3,a:11`
[4/2]	cdcd	5	`lf:5,a:11`
[4/3]	dcdb	4	`lf:2,ls:2,a:16`
[4/4]	ccdc	4	`lf:2,lp:2,a:20`
[5/0]	acdcd	6	`lf:3,lp:3,a:11`
[5/1]	cdcdb	4	`lf:2,ls:2,a:16`
[5/2]	ccdcd	4	`lf:2,lp:2,a:20`
[5/3]	cdcda	4	`lf:2,ls:2,a:11`
[5/4]	dcdda	2	`lf:1,ls:1,a:18`

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

Step 4

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

Rewriting system is complete. See ⟨a, b | abaaab=baaba⟩.