Morphocompletion for #846 ⟨a, b | ababaaab=a⟩

Solved by morph:3/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: rulesLimit

#	Rule
1.	aaaabba ⇒ aabaaab
2.	ababaa ⇒ aaaabb
3.	aabaaabb ⇒ a
4.	aaaabaabba ⇒ aabaaabaab
5.	aabaaababba ⇒ aaaabbbaaab
6.	aabaaabaabba ⇒ aaaab
7.	aaaabbbaba ⇒ aaaababbab
8.	aaaababbaba ⇒ aabaaabaabb
9.	aaaabbbaaabb ⇒ ababa
10.	aabaaabaabaabba ⇒ aaaabaab
11.	aaaababbaaabba ⇒ aaaabab
12.	aaaababbbaaabba ⇒ aaaababb
	...

Collecting factors up to length 7 / frequency 3:

[2/0]	aa	56	`lf:44,lp:11,ls:1,rf:35,rp:10,lprp:9,lsrp:1,a:2`
[2/1]	ba	37	`lf:28,ls:9,rf:13,rs:1,a:2`
[2/2]	ab	31	`lf:30,lp:1,rf:23,rp:1,rs:7,a:2`
[3/0]	aaa	28	`lf:21,lp:7,rf:18,rp:7,lprp:3,a:2`
[3/1]	aab	26	`lf:22,lp:4,rf:17,rp:3,rs:5,lprs:3,a:2`
[3/2]	bba	19	`lf:12,ls:7,rf:2,a:7`
[4/0]	abba	16	`lf:9,ls:7,rf:1,a:7`
[4/1]	aaba	16	`lf:12,lp:4,rf:9,rp:3,a:2`
[4/2]	aaab	14	`lf:14,rf:11,rs:3,a:2`
[5/0]	aaaab	14	`lf:7,lp:7,rf:7,rp:7,rs:1,re:1,lprp:3,a:3`
[5/1]	aabba	12	`lf:6,ls:6,a:7`
[5/2]	aabaa	12	`lf:8,lp:4,rf:6,rp:3,a:2`
[6/0]	aabaaa	8	`lf:4,lp:4,rf:3,rp:3,a:2`
[6/1]	aaaaba	8	`lf:4,lp:4,rf:4,rp:4,lprp:2,a:12`
[6/2]	baabba	6	`lf:3,ls:3,a:11`

Considering [length 3 / frequency 0] aaa=c.

Step 2

Checking up to 20 rules for overlaps.

Auxiliary generators:
1. c = aaa
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.	ca ⇒ ac
2.	aaa ⇒ c
3.	cbabc ⇒ acbcb
4.	ababc ⇒ aabcb
5.	ccbba ⇒ acbcb
6.	acbba ⇒ aabcb
7.	cbabac ⇒ acbcba
8.	ababac ⇒ aabcba
9.	cbabaa ⇒ ccbb
10.	ababaa ⇒ acbb
11.	cbcbb ⇒ aa
12.	aabcbb ⇒ a
13.	ccbbbabc ⇒ ccb
14.	acbbbabc ⇒ acb
15.	ccbbcbba ⇒ ccb
16.	acbbcbba ⇒ acb
	...

Collecting factors up to length 6 / frequency 5:

[2/0]	ba	20	`lf:16,ls:4,rf:2,rs:2,a:5`
[2/1]	cb	18	`lf:14,lp:4,rf:15,rs:8,lprs:1,a:5`
[2/2]	ab	15	`lf:12,lp:3,rf:3,a:5`
[2/3]	bb	14	`lf:12,ls:2,rf:2,rs:2,a:13`
[2/4]	bc	12	`lf:8,ls:4,rf:6,a:5`
[3/0]	cbb	12	`lf:10,ls:2,rf:2,rs:2,a:13`
[3/1]	bba	10	`lf:6,ls:4,a:21`
[3/2]	aba	10	`lf:7,lp:3,a:5`
[3/3]	abc	9	`lf:5,ls:4,rf:3,a:5`
[3/4]	bab	8	`lf:8,a:5`
[4/0]	cbba	8	`lf:4,ls:4,a:21`
[4/1]	babc	8	`lf:4,ls:4,a:5`
[4/2]	bcbb	6	`lf:4,ls:2,a:13`
[4/3]	abab	6	`lf:3,lp:3,a:5`
[4/4]	cbab	6	`lf:3,lp:3,a:6`
[5/0]	bcbba	4	`lf:2,ls:2,a:29`
[5/1]	bbabc	4	`lf:2,ls:2,a:22`
[5/2]	babaa	4	`lf:2,ls:2,a:17`
[5/3]	babac	4	`lf:2,ls:2,a:10`
[5/4]	ababa	4	`lf:2,lp:2,a:14`

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

Step 3

Checking up to 20 rules for overlaps.

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

Rewriting system is not complete: roundsLimit

#	Rule
1.	dddaddc ⇒ dcd
2.	ca ⇒ ac
3.	dddaad ⇒ da
4.	cddaddc ⇒ ccd
5.	addaddc ⇒ acd
6.	cdaad ⇒ aaddc
7.	cddaad ⇒ ac
8.	aaa ⇒ c
9.	dadaad ⇒ dddc
10.	addaad ⇒ aa
11.	aadaad ⇒ addc
12.	dcb ⇒ dddaddaa
13.	dddaab ⇒ d
14.	cdaab ⇒ aaddaa
15.	cddaab ⇒ c
16.	dadaab ⇒ dddaa
17.	addaab ⇒ a
18.	aadaab ⇒ addaa
19.	bc ⇒ daa
20.	ba ⇒ d
	...

Collecting factors up to length 6 / frequency 5:

[2/0]	ad	25	`lf:16,lp:3,ls:6,rf:5,rp:2,lsrp:1,a:3`
[2/1]	aa	20	`lf:16,lp:3,ls:1,rf:8,rp:3,rs:6,re:1,lprs:1,a:1`
[2/2]	da	19	`lf:17,lp:2,rf:7,rp:2,rs:1,re:1,a:3`
[2/3]	dd	18	`lf:15,lp:3,rf:11,rp:3,a:3`
[2/4]	ab	12	`lf:6,ls:6,a:3`
[3/0]	aad	16	`lf:8,lp:2,ls:6,rf:2,rp:2,lsrp:1,a:8`
[3/1]	aab	12	`lf:6,ls:6,a:3`
[3/2]	daa	12	`lf:12,rf:5,rp:1,rs:5,re:1,a:3`
[3/3]	add	9	`lf:6,lp:3,rf:5,rp:2,a:3`
[3/4]	dda	9	`lf:9,rf:5,a:3`
[4/0]	daab	12	`lf:6,ls:6,a:3`
[4/1]	daad	12	`lf:6,ls:6,a:8`
[4/2]	adda	6	`lf:3,lp:3,rf:3,rp:1,a:3`
[4/3]	ddaa	6	`lf:6,rf:4,rs:4,a:3`
[4/4]	cdda	6	`lf:3,lp:3,a:6`
[5/0]	ddaab	6	`lf:3,ls:3,a:3`
[5/1]	ddaad	6	`lf:3,ls:3,a:8`
[5/2]	daddc	6	`lf:3,ls:3,a:20`
[5/3]	adaab	4	`lf:2,ls:2,a:11`
[5/4]	aadaa	4	`lf:2,lp:2,a:13`

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

Step 4

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

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