Morphocompletion for #2922 ⟨a, b | aaabaabbaba=1⟩

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

#	Rule
1.	bbabaaa ⇒ aabaabb
2.	aaaabaabbab ⇒ 1
3.	baabbaba ⇒ abaabbab
4.	aabaabbaabaabbab ⇒ bbaba
5.	aabaabbaaabaabbab ⇒ bbabaa
6.	aabaabbabbbaba ⇒ baabbaabaabbab
7.	aabaabbabbaabbabbbaba ⇒ baabbabbaabbaabaabbab
8.	aabaabbabbaabbabbaabbabbbaba ⇒ baabbabbaabbabbaabbaabaabbab
9.	aabaabbabbaabbabbaabbabbaabbabbbaba ⇒ baabbabbaabbabbaabbabbaabbaabaabbab
10.	aabaabbabbaabbabbaabbabbaabbabbaabbabbbaba ⇒ baabbabbaabbabbaabbabbaabbabbaabbaabaabbab
11.	aabaabbabbaabbabbaabbabbaabbabbaabbabbaabbabbbaba ⇒ baabbabbaabbabbaabbabbaabbabbaabbabbaabbaabaabbab
12.	aabaabbabbaabbabbaabbabbaabbabbaabbabbaabbabbaabbabbbaba ⇒ baabbabbaabbabbaabbabbaabbabbaabbabbaabbabbaabbaabaabbab
	...

Collecting factors up to length 7 / frequency 4:

[2/0]	ba	94	`lf:85,lp:1,ls:8,rf:77,rp:7,rs:1,lsrp:7,a:3`
[2/1]	ab	89	`lf:86,ls:3,rf:77,rp:1,rs:8,a:3`
[2/2]	bb	71	`lf:70,lp:1,rf:60,rp:2,rs:1,lprs:1,a:3`
[2/3]	aa	62	`lf:51,lp:10,ls:1,rf:46,rp:1,rs:1,lsrp:1,lprs:1,a:3`
[3/0]	bba	64	`lf:63,lp:1,rf:59,rp:2,a:3`
[3/1]	abb	62	`lf:62,rf:58,rs:1,a:3`
[3/2]	aab	55	`lf:46,lp:9,rf:45,rp:1,a:3`
[3/3]	bab	43	`lf:40,ls:3,rf:31,rs:8,a:3`
[4/0]	abba	55	`lf:55,rf:57,a:3`
[4/1]	bbab	44	`lf:40,lp:1,ls:3,rf:31,rp:2,rs:8,lsrp:2,a:3`
[4/2]	baab	36	`lf:35,lp:1,rf:44,rp:7,a:3`
[4/3]	aabb	34	`lf:34,rf:37,rs:1,a:3`
[5/0]	abbab	35	`lf:32,ls:3,rf:29,rs:8,a:3`
[5/1]	baabb	35	`lf:34,lp:1,rf:37,rp:7,rs:1,a:3`
[5/2]	aabba	34	`lf:34,rf:36,a:3`
[5/3]	bbabb	28	`lf:28,rf:21,a:4`
[6/0]	baabba	35	`lf:34,lp:1,rf:36,rp:7,a:3`
[6/1]	aabbab	35	`lf:32,ls:3,rf:29,rs:8,a:3`
[6/2]	abbabb	28	`lf:28,rf:21,a:4`
[6/3]	abbaab	22	`lf:22,rf:28,a:4`

Considering [length 5 / frequency 0] abbab=c.

Step 2

Checking up to 20 rules for overlaps.

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

Rewriting system is not complete: roundsLimit

#	Rule
1.	caaaaba ⇒ 1
2.	aaabac ⇒ caaaab
3.	aaaabac ⇒ 1
4.	baca ⇒ abac
5.	acaaac ⇒ bab
6.	cacaaa ⇒ abb
7.	aaabaabb ⇒ caaa
8.	abbab ⇒ c
9.	babaaaaba ⇒ acaaa
10.	abbc ⇒ cbab
11.	caaaabc ⇒ bbab
12.	aaabacc ⇒ bbab
13.	abaccaaa ⇒ baabb
14.	cbabaaaaba ⇒ abb
15.	abbaabac ⇒ caca
16.	abbaaabac ⇒ cacaa
17.	abbbbab ⇒ cacaac
18.	abacbbab ⇒ bacc
	...

Collecting factors up to length 6 / frequency 7:

[2/0]	aa	37	`lf:31,lp:4,ls:2,rf:10,rs:3,lprs:1,a:4`
[2/1]	ab	33	`lf:23,lp:7,ls:3,rf:9,rp:3,rs:5,lprs:1,a:1`
[2/2]	ba	26	`lf:21,lp:2,ls:3,rf:7,rp:3,a:1`
[2/3]	ac	17	`lf:11,lp:1,ls:5,rf:7,rp:1,rs:2,a:4`
[2/4]	ca	11	`lf:7,lp:3,ls:1,rf:9,rp:5,rs:1,a:10`
[2/5]	bb	10	`lf:9,ls:1,rf:5,rp:2,rs:3,a:1`
[2/6]	bc	4	`lf:2,ls:2,a:3`
[3/0]	aaa	23	`lf:17,lp:4,ls:2,rf:4,rs:2,lprs:1,a:4`
[3/1]	aba	18	`lf:13,lp:2,ls:3,rf:1,rp:1,a:4`
[3/2]	bac	13	`lf:8,lp:1,ls:4,rf:2,rp:1,rs:1,lprs:10,a:4`
[3/3]	abb	12	`lf:6,lp:5,ls:1,rf:3,rp:2,rs:3,re:2,a:1`
[3/4]	aab	11	`lf:11,rf:2,rs:1,a:4`
[3/5]	bab	9	`lf:5,lp:1,ls:3,rf:4,rp:1,rs:4,re:1,a:1`
[3/6]	caa	7	`lf:5,lp:2,rf:5,rp:2,rs:1,a:16`
[4/0]	abac	13	`lf:7,lp:2,ls:4,rf:1,rp:1,rs:1,re:1,a:4`
[4/1]	aaba	12	`lf:9,ls:3,a:4`
[4/2]	aaab	12	`lf:9,lp:3,rf:1,rs:1,lprs:1,a:4`
[4/3]	caaa	9	`lf:5,lp:2,ls:2,rf:3,rp:2,rs:2,re:1,a:21`
[4/4]	bbab	6	`lf:3,ls:3,rf:2,rp:2,rs:2,re:2,a:1`
[4/5]	abba	6	`lf:3,lp:3,a:1`
[4/6]	aaaa	6	`lf:5,lp:1,rf:1,a:29`
[5/0]	aaaba	14	`lf:8,lp:3,ls:3,a:4`
[5/1]	aabac	9	`lf:5,ls:4,a:4`
[5/2]	aaaab	6	`lf:5,lp:1,rf:1,rs:1,a:29`
[5/3]	abacc	4	`lf:2,lp:1,ls:1,a:4`
[5/4]	abbaa	4	`lf:2,lp:2,a:11`
[5/5]	caaaa	4	`lf:2,lp:2,rf:1,rp:1,a:37`
[5/6]	acaaa	4	`lf:2,lp:1,ls:1,rf:1,rp:1,rs:1,re:1,a:21`

Considering [length 4 / frequency 0] abac=d.

Step 3

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

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