Morphocompletion for #15365 ⟨a, b | aba=bb, aaaaaa=1⟩

Solved by morph:4/0,4/0,5/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.	bbba ⇒ abbb
2.	aba ⇒ bb
3.	babbabba ⇒ aaabbbbbbbb
4.	bbaaabbbbb ⇒ abbabba
5.	aaaabbbbb ⇒ babba
6.	bbaaaabb ⇒ abba
7.	bbaaabbabbb ⇒ abbabbaa
8.	aaaaabb ⇒ ba
9.	aaaabbabbb ⇒ babbaa
10.	babbaabbabba ⇒ aaabbaabbbbbbbbbbb
11.	bbaaaaa ⇒ ab
12.	bbaaabbaabbb ⇒ abbabbaaa
13.	bbaaabbabbabbb ⇒ abbabbaabba
14.	aaaaaa ⇒ 1
15.	aaaabbaabbb ⇒ babbaaa
16.	aaaabbabbabbb ⇒ babbaabba
17.	bbaaabbaaabbb ⇒ abbabbaaaa
18.	bbaaabbaabbabbb ⇒ abbabbaaabba
19.	bbaaabbabbaabbb ⇒ abbabbaabbaa
20.	aaaabbaaabbb ⇒ babbaaaa
21.	aaaabbaabbabbb ⇒ babbaaabba
22.	aaaabbabbaabbb ⇒ babbaabbaa
23.	babbaabbaaaa ⇒ aaaabbaabbab
24.	babbaabbaabbabba ⇒ aaabbaabbaabbbbbbbbbbbbbb
25.	bbaaabbaabbaabbb ⇒ abbabbaaabbaa
26.	bbaaabbaabbabba ⇒ abbabbaabbaaabb
27.	bbaaabbabbaaabbb ⇒ abbabbaabbaaa
28.	bbaaabbabbaabbabbb ⇒ abbabbaabbaabba
29.	aaaabbaabbaabbb ⇒ babbaaabbaa
30.	aaaabbaabbabba ⇒ babbaabbaaabb
31.	aaaabbabbaaabbb ⇒ babbaabbaaa
32.	aaaabbabbaabbabbb ⇒ babbaabbaabba
33.	babbaaabbaaaa ⇒ aaaabbaaabbab
34.	bbaaabbaaabbabba ⇒ abbabbaaabbaaabb
35.	bbaaabbaabbaaabbb ⇒ abbabbaaabbaaa
36.	bbaaabbaabbaabbabbb ⇒ abbabbaaabbaabba
37.	bbaaabbabbaabbaabbb ⇒ abbabbaabbaabbaa
38.	aaaabbaaabbabba ⇒ babbaaabbaaabb
39.	aaaabbaabbaaabbb ⇒ babbaaabbaaa
40.	aaaabbaabbaabbabbb ⇒ babbaaabbaabba
41.	aaaabbabbaabbaabbb ⇒ babbaabbaabbaa
42.	babbaaabbabbaaaa ⇒ aaaabbaabbaabbab
43.	babbaabbaaabbaaabb ⇒ aaaabbaabbaabba
44.	babbaabbaabbaaaa ⇒ aaaabbabbaaabbab
45.	bbaaabbaaabbaabbab ⇒ abbaabbaabbaaaa
46.	bbaaabbaabbaabbaabbb ⇒ abbabbaaabbaabbaa
47.	bbaaabbaabbaabbabba ⇒ abbabbaaabbabbaaabb
48.	bbaaabbabbaaabbabba ⇒ abbabbaabbaabbaaabb
49.	bbaaabbabbaabbaaabbb ⇒ abbabbaabbaabbaaa
50.	bbaaabbabbaabbaabbabbb ⇒ abbabbaabbaabbaabba
51.	aaaabbaaabbaabbab ⇒ baabbaabbaaaa
52.	aaaabbaabbaabbaabbb ⇒ babbaaabbaabbaa
53.	aaaabbaabbaabbabba ⇒ babbaaabbabbaaabb
54.	aaaabbabbaaabbabba ⇒ babbaabbaabbaaabb
55.	aaaabbabbaabbaaabbb ⇒ babbaabbaabbaaa
56.	aaaabbabbaabbaabbabbb ⇒ babbaabbaabbaabba
57.	babbaaabbaaabbaaabb ⇒ aaaabbaaabbaabba
58.	babbaaabbaabbaaaa ⇒ aaaabbaabbaaabbab
59.	babbaabbaaabbaaaa ⇒ aaaabbaabbaab
60.	bbaaabbaaabbaaabbab ⇒ abbaabbaaabbaaaa
61.	bbaaabbaabbaaabbabba ⇒ abbabbaaabbaabbaaabb
62.	bbaaabbaabbaabbaaabbb ⇒ abbabbaaabbaabbaaa
63.	aaaabbaaabbaaabbab ⇒ baabbaaabbaaaa
64.	aaaabbaabbaaabbabba ⇒ babbaaabbaabbaaabb
65.	aaaabbaabbaabbaaabbb ⇒ babbaaabbaabbaaa
66.	aaaabbaabbaabbaabbabbb ⇒ babbaaabbaabbaabba
67.	aaaabbabbaabbaabbaabbb ⇒ babbaabbaabbaabbaa
68.	baabbaabbaaabbaaaa ⇒ aaaabbaaabbaabbaab
69.	baabbabbaabbaaabbaaa ⇒ aaaabbaabbaabbaabbab
70.	babbaaabbaaabbaaaa ⇒ aaaabbaaabbaab
71.	babbaaabbabbaaabbaaabb ⇒ aaaabbaabbaabbaabba
72.	babbaabbaaabbabbaaaa ⇒ aaaabbabbaaabbaabbab
73.	babbaabbaabbaaabbaaa ⇒ aaabbaaabbaabbaabbab
74.	babbaabbaabbaabbaaaa ⇒ aaaabbabbaabbaaabbab
75.	bbaaabbaaabbaabbaabba ⇒ abbaabbaabbaaabbaaabb
76.	aaaabbaaabbaabbaabba ⇒ baabbaabbaaabbaaabb
77.	baabbaaabbaaabbaaaa ⇒ aaaabbaaabbaaabbaab
78.	aaaabbaaabbaaabbaabba ⇒ baabbaaabbaaabbaaabb
79.	aaaabbaaabbaabbaaabbab ⇒ baabbaaabbaabbaaaa
80.	babbaaabbaabbaaabbaaaa ⇒ aaaabbaabbaaabbaab
	...

Collecting factors up to length 5, frequency 1:

Length 2:	[2/0] aa
Length 3:	[3/0] aaa
Length 4:	[4/0] aaaa

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

Step 2

Checking up to 80 rules for overlaps.

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

Rewriting system is not complete: arenaTotalLimit

#	Rule
1.	bbbc ⇒ cbbb
2.	bbba ⇒ abbb
3.	bcc ⇒ cbbcbb
4.	bbcbbc ⇒ ccb
5.	cabb ⇒ ba
6.	bbca ⇒ ab
7.	ac ⇒ ca
8.	abcbb ⇒ bbcba
9.	babc ⇒ cbab
10.	aa ⇒ cc
11.	aba ⇒ bb
12.	abba ⇒ bbcbb
13.	ccc ⇒ 1
14.	bbcbcbbcbb ⇒ ccbc
15.	ccba ⇒ abb
16.	ccbba ⇒ abbcbb
17.	cbbcbab ⇒ babbc
18.	cbbcbbabb ⇒ bcba
19.	bcbbcbba ⇒ abc
20.	abcbcbbb ⇒ bbcbabbc
21.	abca ⇒ bbc
22.	abcba ⇒ bcbbcbbbb
23.	abbcba ⇒ ccbcbb
24.	ccbcbbcbb ⇒ abbcbba
25.	cbcbbcbcbbbbbbbb ⇒ babbcbba
26.	bbcbcbcbbcbbbbb ⇒ ccbcbc
27.	bbcbcbbcbcbbb ⇒ ccbcbbc
28.	ccbca ⇒ abbc
29.	ccbcba ⇒ bbcbbabb
30.	ccbcbba ⇒ bbcbbabbcbb
31.	cbbcbcbabbbb ⇒ bcbabbc
32.	cbbcbcbbabbbbb ⇒ bcbcba
33.	bcbbcbcbab ⇒ abcbc
34.	abcbcbcbbb ⇒ bbcbabbcbc
35.	abcbcbbc ⇒ bcbbcbcbbab
36.	babbcbcbbcb ⇒ cbbcbcba
37.	abcbca ⇒ bcbbcbcbbb
38.	abcbcba ⇒ bbabbcbbabb
39.	abcbcbbabbb ⇒ bbcbabbcbba
40.	abbcbca ⇒ ccbcbbc
41.	abbcbcba ⇒ bbcbbabbcbbabb
42.	abbcbbabbcbbbbb ⇒ cbabbcbba
43.	bbabbcbbabbcbb ⇒ abcbcbba
44.	ccbcbcbbcbb ⇒ bbcbbabbcbba
45.	ccbcbbcbcbbb ⇒ abbcbbabbc
46.	bbcbcbbcbcbcbbb ⇒ ccbcbbcbc
47.	ccbcbca ⇒ bbcbbabbc
48.	ccbcbcba ⇒ bbcbcbbabbbbb
49.	ccbcbcbba ⇒ bbcbcbbabbcbbbbb
50.	ccbcbbcba ⇒ abbcbcbb
51.	cbcbbcbcbbabbbb ⇒ babbcbcbbc
52.	cbbcbcbcbabbbbbbb ⇒ bcbcbabbc
53.	bbcbcbbcbcbbab ⇒ abbcbcbbc
54.	cbbcbcbabbcbbb ⇒ bcbabbcbc
55.	cbbcbcbbabbcbbb ⇒ bcbcbca
56.	bcbabbcbcbbc ⇒ cbbcbcbcbabb
57.	abcbcbcbcbbb ⇒ bbcbabbcbcbc
58.	abcbcbcbbcbb ⇒ bcbbcbcbcbab
59.	abcbcbca ⇒ bbabbcbbabbc
60.	abcbcbcba ⇒ bbabbcbcbbabbbbb
61.	abcbcbcbbabbb ⇒ bbcbabbcbcbba
62.	abbcbcbca ⇒ bbcbbabbcbbabbc
63.	abbcbcbbcba ⇒ ccbcbbcbcbb
64.	abbcbbabbcbbabb ⇒ ccbbcbcba
65.	ccbcbcbcbbc ⇒ bbcbcbbabbcbbab
66.	bcbcbbcbcbbcbcbb ⇒ b
67.	ccbcbcbca ⇒ bbcbcbbabbcbbb
68.	ccbcbcbbcba ⇒ bbcbbabbcbcbb
69.	ccbcbbcbca ⇒ abbcbcbbc
70.	cbbcbcbbcbcba ⇒ bcbcbbcbcab
71.	cbbcbcabcbcb ⇒ bcbcbcbbcbca
72.	cbbcbcbbabbcbbab ⇒ bcbcbcbbc
73.	abbcbcbbcbca ⇒ ccbcbbcbcbbc
74.	bcbcbbcbcbbcbcab ⇒ bca
75.	abcbcbcbbcbca ⇒ bcbbcbcbcb
76.	ccbcbcbbcbcbbcbcab ⇒ abbc
	...

Collecting factors up to length 7, frequency 1:

Length 2:	[2/0] bb
Length 3:	[3/0] bbb
Length 4:	[4/0] cbbc
Length 5:	[5/0] bbcbb
Length 6:	[6/0] cbcbbc

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

Step 3

Checking up to 80 rules for overlaps.

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

Rewriting system is not complete: roundsLimit

#	Rule
1.	bbbc ⇒ cbbb
2.	bbbd ⇒ dbbb
3.	bbba ⇒ abbb
4.	ccb ⇒ bbd
5.	cbbc ⇒ d
6.	bcc ⇒ dbb
7.	cbbd ⇒ b
8.	cabb ⇒ ba
9.	bbca ⇒ ab
10.	dc ⇒ cbdbb
11.	dbcbbb ⇒ bcd
12.	dbbc ⇒ b
13.	bbdbc ⇒ cd
14.	dbdbb ⇒ bc
15.	dbbd ⇒ cbbb
16.	bbdbd ⇒ cb
17.	da ⇒ cab
18.	dbbabb ⇒ bcba
19.	bbdbba ⇒ cbab
20.	ac ⇒ ca
21.	abc ⇒ bdbba
22.	abbcbb ⇒ bbdba
23.	babbc ⇒ dbab
24.	ad ⇒ bca
25.	abdbb ⇒ bbcbba
26.	abbdb ⇒ cba
27.	babd ⇒ cbbab
28.	babbd ⇒ dbbab
29.	aa ⇒ cc
30.	aba ⇒ bb
31.	abba ⇒ bbcbb
32.	ccc ⇒ 1
33.	ccd ⇒ bbc
34.	ccab ⇒ abbd
35.	bbcbca ⇒ abd
36.	bbcbdbba ⇒ abbc
37.	dbcbcbbb ⇒ bcdbc
38.	dbcdbbb ⇒ bcdd
39.	dbcbdbbb ⇒ bcdbd
40.	dbca ⇒ cabd
41.	dbcbabbb ⇒ bcdba
42.	dbdbcb ⇒ bcbdbd
43.	dbddbbb ⇒ bcbd
44.	bdbdbd ⇒ dbdbdb
45.	dbdbab ⇒ bcbca
46.	abbcd ⇒ bbcbdbab
47.	abbddbb ⇒ cdbba
48.	abdba ⇒ bbcbcbb
49.	bbcbcbca ⇒ abdd
50.	bcbcbdbd ⇒ dbddb
51.	bcdbdbc ⇒ dbdd
52.	bcbdbdbc ⇒ dbdbd
53.	bcddbd ⇒ dbcbcb
54.	bcdbdbd ⇒ dbdb
55.	cabdbcbb ⇒ dbdba
56.	dbcbcd ⇒ bcddbc
57.	dbcbca ⇒ cabdd
58.	dbcddbbb ⇒ bcddd
59.	dbdbcd ⇒ bcbdbc
60.	ddbdbc ⇒ cbdbdd
61.	dddbd ⇒ cbdbcbcb
62.	ddbdbd ⇒ cbdbdb
63.	dbddd ⇒ bcbcbdbc
64.	dbdbdd ⇒ bdbdbc
65.	abbcbdbab ⇒ cdd
66.	abbddba ⇒ cdbcbb
	...

Collecting factors up to length 8, frequency 1:

Length 2:	[2/0] bb
Length 3:	[3/0] bbb
Length 4:	[4/0] dbdb
Length 5:	[5/0] dbdbd
Length 6:	[6/0] dbcbcb
Length 7:	[7/0] bbcbcbb

Considering [length 5 / frequency 0] dbdbd=e.

Step 4

Auxiliary generators:
1. c = aaaa
2. d = cbbc
3. e = dbdbd
Reduction order:
- Left-to-right recursive path with deg(b) = 0; deg(e) = 1; deg(c) = deg(d) = deg(a) = 2, c < d < a

Rewriting system is complete. See ⟨a, b | aba=bb, aaaaaa=1⟩.