Morphocompletion for #17137 ⟨a, b | aaaa=1, abbbba=b⟩

Solved by morph:4/0,4/0. (See Morphocompletion.)

Step 1

Checking up to 80 rules for overlaps.

Reduction order:
- Left-to-right recursive path with deg(b) = 0; deg(a) = 1

Rewriting system is not complete: roundsLimit

#	Rule
1.	bbbbba ⇒ abbbbb
2.	abbbba ⇒ b
3.	baa ⇒ abbbabbbb
4.	bbbbabbba ⇒ aab
5.	aaab ⇒ bbbba
6.	abbbabbbabbbb ⇒ ba
7.	bbbbabbabbbabbbb ⇒ aaba
8.	aaaa ⇒ 1
9.	abbbabbabbbabbbbbbbbb ⇒ baba
10.	abbbabbbababbbbb ⇒ babba
11.	abbbabbbabbabbbbb ⇒ babbba
12.	bababbbabbba ⇒ abbbabbbabab
13.	babbabbbabbba ⇒ abbbabbbabbab
14.	babbbabbbabbba ⇒ abbbabbbabbbab
15.	bbbbabbabbabbbabbbbbbbbb ⇒ aababa
16.	bbbbabbabbbababbbbb ⇒ aababba
17.	bbbbabbabbbabbabbbbb ⇒ aababbba
18.	abbbabbabbabbbabbbbbbbbbbbbbb ⇒ bababa
19.	abbbabbabbbababbbbbbbbbb ⇒ bababba
20.	abbbabbabbbabbabbbbbbbbbb ⇒ bababbba
21.	abbbabbbabababbbbb ⇒ babbaba
22.	abbbabbbababbabbbbb ⇒ babbabba
23.	abbbabbbababbbabbbbb ⇒ babbabbba
24.	abbbabbbabbababbbbb ⇒ babbbaba
25.	abbbabbbabbabbabbbbb ⇒ babbbabba
26.	abbbabbbabbabbbabbbbb ⇒ babbbabbba
27.	abbbabbbabbbabab ⇒ bbabbbabbba
28.	abbbabbbabbbabbab ⇒ bbbabbbabbba
29.	bababbbabbabbbabbbb ⇒ abbbabbbababa
30.	babbabbbabbabbbabbbb ⇒ abbbabbbabbaba
31.	babbbabbbabbabbbabbbb ⇒ abbbabbbabbbaba
32.	bbbabbbabbbabbabab ⇒ aababbbabbba
33.	bbbabbbabbbabbabbab ⇒ aabbabbbabbba
34.	bbbabbbabbbabbabbbab ⇒ aabbbabbbabbba
35.	bbbbabbabbabbbababbbbbbbbbb ⇒ aabababba
36.	bbbbabbabbbabababbbbb ⇒ aababbaba
37.	bbbbabbabbbababbabbbbb ⇒ aababbabba
38.	bbbbabbabbbababbbabbbbb ⇒ aababbabbba
39.	bbbbabbabbbabbababbbbb ⇒ aababbbaba
40.	bbbbabbabbbabbabbabbbbb ⇒ aababbbabba
41.	abbbabbabbbabababbbbbbbbbb ⇒ bababbaba
42.	abbbabbabbbababbabbbbbbbbbb ⇒ bababbabba
43.	abbbabbabbbabbababbbbbbbbbb ⇒ bababbbaba
44.	abbbabbbababababbbbb ⇒ babbababa
45.	abbbabbbabababbabbbbb ⇒ babbababba
46.	abbbabbbabababbbabbbbb ⇒ babbababbba
47.	abbbabbbababbababbbbb ⇒ babbabbaba
48.	abbbabbbababbabbabbbbb ⇒ babbabbabba
49.	abbbabbbababbabbbabbbbb ⇒ babbabbabbba
50.	abbbabbbababbbababbbbb ⇒ babbabbbaba
51.	abbbabbbababbbabbabbbbb ⇒ babbabbbabba
52.	abbbabbbabbabababbbbb ⇒ babbbababa
53.	abbbabbbabbababbabbbbb ⇒ babbbababba
54.	abbbabbbabbababbbabbbbb ⇒ babbbababbba
55.	abbbabbbabbabbababbbbb ⇒ babbbabbaba
56.	abbbabbbabbabbabbabbbbb ⇒ babbbabbabba
57.	abbbabbbabbabbabbbabbbbb ⇒ babbbabbabbba
58.	abbbabbbabbabbbababbbbb ⇒ babbbabbbaba
59.	abbbabbbabbabbbabbabbbbb ⇒ babbbabbbabba
60.	babababbbabbabbba ⇒ abbbabbabbbababab
61.	bababbabbbabbabbba ⇒ abbbabbabbbabbabab
62.	bbbbabbabbbababababbbbb ⇒ aababbababa
63.	bbbbabbabbbabababbabbbbb ⇒ aababbababba
64.	bbbbabbabbbababbababbbbb ⇒ aababbabbaba
65.	bbbbabbabbbabbabababbbbb ⇒ aababbbababa
66.	abbabbbabbbabbababab ⇒ bababbbabbabbba
67.	abbabbbabbbabbabbabab ⇒ babbabbbabbabbba
68.	abbbabbbabababababbbbb ⇒ babbabababa
69.	abbbabbbababababbabbbbb ⇒ babbabababba
70.	abbbabbbababababbbabbbbb ⇒ babbabababbba
71.	abbbabbbabababbababbbbb ⇒ babbababbaba
72.	abbbabbbabababbabbabbbbb ⇒ babbababbabba
73.	abbbabbbabababbbababbbbb ⇒ babbababbbaba
74.	abbbabbbababbabababbbbb ⇒ babbabbababa
75.	abbbabbbababbababbabbbbb ⇒ babbabbababba
76.	abbbabbbababbabbababbbbb ⇒ babbabbabbaba
77.	abbbabbbababbbabababbbbb ⇒ babbabbbababa
78.	abbbabbbabbababababbbbb ⇒ babbbabababa
79.	abbbabbbabbabababbabbbbb ⇒ babbbabababba
	...

Collecting factors up to length 7 / frequency 2:

[2/0]	ba	3764	`lf:362,lp:9,ls:8,rf:269,rp:46,rs:69,re:1,lprs:3,a:1`
[2/1]	bb	2044	`lf:739,lp:19,ls:61,rf:220,rp:3,rs:2,lprs:1,a:1`
[3/0]	bab	7618	`lf:353,lp:8,ls:7,rf:200,rp:45,rs:5,lsrp:2,lprs:5,a:6`
[3/1]	bbb	1575	`lf:415,lp:19,ls:61,rf:76,rp:2,rs:2,lprs:1,a:1`
[4/0]	bbba	3273	`lf:172,lp:3,ls:8,rf:70,rp:1,rs:19,lprs:3,a:1`
[4/1]	bbbb	1266	`lf:182,lp:16,ls:61,rf:4,rp:1,rs:2,lprs:1,a:1`
[5/0]	abbba	16299	`lf:152,lp:46,ls:6,rf:68,rp:9,rs:18,lsrp:5,lprs:11,a:6`
[5/1]	bbbbb	10163	`lf:104,lp:1,ls:56,rf:1,rs:1,lprs:10,a:4`
[6/0]	babbab	1166	`lf:89,lp:2,ls:2,rf:50,rp:22,rs:1,lprs:1,a:9`
[6/1]	abbbab	253	`lf:146,lp:46,ls:1,rf:50,rp:9,rs:1,a:7`

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

Step 2

Checking up to 80 rules for overlaps.

Auxiliary generators:
1. c = bbba
Reduction order:
- Left-to-right recursive path with deg(b) = 0; deg(c) = deg(a) = 1, c < a

Rewriting system is not complete: roundsLimit

#	Rule
1.	bbbbbc ⇒ cbbbbb
2.	abbbbb ⇒ bbc
3.	bbba ⇒ c
4.	cbc ⇒ bbbb
5.	bcbbc ⇒ ccbbbbbbbbb
6.	bbbbccbbbb ⇒ cbbc
7.	cab ⇒ bbbbcc
8.	bca ⇒ ccbbbb
9.	acbbbbb ⇒ bbcc
10.	abc ⇒ b
11.	abbc ⇒ bccbbbb
12.	abbbc ⇒ bbcba
13.	abbbbc ⇒ bbcbba
14.	bbacbbbb ⇒ ca
15.	aab ⇒ bcc
16.	baa ⇒ acbbbb
17.	cccbbbb ⇒ bc
18.	bccc ⇒ ab
19.	bbbbccbbcbbbbb ⇒ cbbcbbbc
20.	cbbcba ⇒ bbbbccbbc
21.	cbbcbba ⇒ bbbbccbbbc
22.	cac ⇒ bbbbccbba
23.	caa ⇒ bbabbbb
24.	accbbbb ⇒ ba
25.	acbbc ⇒ bbcca
26.	acbbbc ⇒ bbccba
27.	acbbbbc ⇒ bbccbba
28.	aac ⇒ bccbba
29.	ccccb ⇒ b
30.	cccbbc ⇒ bcba
31.	cccbbbc ⇒ bcbba
32.	bccbbbbcc ⇒ abab
33.	cbbcca ⇒ bbbbccbbbccbbbb
34.	bcbacc ⇒ cccbab
35.	bcbbacc ⇒ cccbbab
36.	acccbbb ⇒ cccc
37.	accbbc ⇒ baba
38.	accbbbc ⇒ babba
39.	baccc ⇒ acccb
40.	bbaccbab ⇒ cbacc
41.	bbaccbbab ⇒ cbbacc
42.	babacc ⇒ accbab
43.	babbacc ⇒ accbbab
44.	aaaa ⇒ 1
45.	ccccc ⇒ c
46.	ccbbbbccbbc ⇒ bcbaba
47.	ccbbbbccbbbc ⇒ bcbabba
48.	bccbbbbcbbbbcc ⇒ ababab
49.	bbcbbbccbbac ⇒ abbabab
50.	bbcbbbbccbbac ⇒ acbab
51.	cccbabab ⇒ bcbbbccbbac
52.	cccbbabab ⇒ bcbbbbccbbac
53.	bccbacc ⇒ cccbbabbab
54.	bccbbacc ⇒ cccbbacb
55.	acccc ⇒ cccca
56.	acccbab ⇒ bbacc
57.	acccbba ⇒ ccbbaccbbb
58.	bbaccbac ⇒ cbaccbba
59.	bbaccbbac ⇒ cbbaccbba
60.	accbabab ⇒ bbbcbacbbac
61.	accbbabab ⇒ bbbcbbacbbac
62.	bacbacc ⇒ accbbabbab
63.	bacbbacc ⇒ accbbacb
64.	bbccbbccbbac ⇒ acbabab
65.	bbccbbbccbbac ⇒ acbbabab
66.	cccbbaccb ⇒ accc
67.	cccbbacbab ⇒ abacc
68.	cccbbacbbab ⇒ abbacc
69.	acccbac ⇒ bbaccbba
70.	accbbaccbb ⇒ ccbbaccbba
71.	baccbbacc ⇒ accbbaccb
72.	accbbacbbab ⇒ baccbacc
73.	cccbbacca ⇒ acbbaccbbb
74.	cccbbacbac ⇒ abaccbba
75.	cccbbacbbac ⇒ abbaccbba
	...

Collecting factors up to length 14 / frequency 1:

[2/0]	cc	8196	`lf:87,lp:15,ls:15,rf:58,rp:10,rs:11,lsrp:5,lprs:3,a:9`
[3/0]	acc	7087	`lf:30,lp:12,ls:9,rf:23,rp:7,rs:6,lsrp:5,lprs:2,a:29`
[4/0]	accc	10018	`lf:6,lp:5,ls:1,rf:2,rp:2,rs:1,re:1,lsrp:10,a:41`
[5/0]	bbbbb	10016	`lf:4,lp:1,ls:3,rf:6,rs:2,lprs:10,a:14`
[6/0]	accbba	1029	`lf:6,lp:3,rf:10,rp:4,rs:6,lprs:1,a:75`
[7/0]	baccbba	16	`lf:3,lp:1,rf:6,rs:6,a:84`
[8/0]	bbaccbba	10014	`lf:2,lp:2,rf:4,rp:1,rs:4,re:1,lprs:10,a:84`
[9/0]	ccbbaccbb	10006	`lf:1,ls:1,rf:2,rp:2,lsrp:10,a:114`
[10/0]	bbbbccbbbc	8	`lf:1,ls:1,rf:2,rp:2,rs:1,re:1,a:70`
[11/0]	bcbbbccbbac	6	`lf:1,ls:1,rf:1,rp:1,rs:1,re:1,a:90`
[12/0]	bcbbbbccbbac	6	`lf:1,ls:1,rf:1,rp:1,rs:1,re:1,a:58`
[13/0]	ccbbbbcbbbbcc	2	`lf:1,ls:1,a:104`

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

Step 3

Auxiliary generators:
1. c = bbba
2. d = accc
Reduction order:
- Left-to-right recursive path with deg(b) = deg(d) = 0, b < d; deg(c) = deg(a) = 1, c < a

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