Morphocompletion for #21739 ⟨a, b | aaa=1, abbabba=b⟩

Solved by morph:5/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.	baa ⇒ abbabb
3.	bbabba ⇒ aab
4.	aaa ⇒ 1
5.	bbababbabb ⇒ aaba
6.	bbabababbabbbbb ⇒ aababa
7.	bbababbababbb ⇒ aababba
8.	bababbababba ⇒ abbababbabab
9.	bbababababbabbbbbbbb ⇒ aabababa
10.	bbabababbababbbbbb ⇒ aabababba
11.	bbababbabababbb ⇒ aababbaba
12.	bababbabababbabb ⇒ abbababbababa
13.	babbababbababab ⇒ aababbababba
14.	bbabababababbabbbbbbbbbbb ⇒ aababababa
15.	bbababababbababbbbbbbbb ⇒ aababababba
16.	bbabababbabababbbbbb ⇒ aabababbaba
17.	bbababbababababbb ⇒ aababbababa
18.	babababbabababba ⇒ abbabababbababab
19.	bababbababababbabbbbb ⇒ abbababbabababa
20.	bababbabababbababbb ⇒ abbababbabababba
21.	bbababababababbabbbbbbbbbbbbbb ⇒ aabababababa
22.	bbabababababbababbbbbbbbbbbb ⇒ aabababababba
23.	bbababababbabababbbbbbbbb ⇒ aababababbaba
24.	bbabababbababababbbbbb ⇒ aabababbababa
25.	bbababbabababababbb ⇒ aababbabababa
26.	bbababbababababbabbb ⇒ aababbabababba
27.	babababbababababbabb ⇒ abbabababbabababa
28.	bababbabababababbabbbbbbbb ⇒ abbababbababababa
29.	bababbababababbababbbbbb ⇒ abbababbababababba
30.	bababbabababbabababbb ⇒ abbababbabababbaba
31.	babbabababbababababbbb ⇒ aabababbabababba
32.	bbabababababababbabbbbbbbbbbbbbbbbb ⇒ aababababababa
33.	bbababababababbababbbbbbbbbbbbbbb ⇒ aababababababba
34.	bbabababababbabababbbbbbbbbbbb ⇒ aabababababbaba
35.	bbababababbababababbbbbbbbb ⇒ aababababbababa
36.	bbabababbabababababbbbbb ⇒ aabababbabababa
37.	bbababbababababababbb ⇒ aababbababababa
38.	bbababbabababababbabbb ⇒ aababbababababba
39.	bbababbababababbababbb ⇒ aababbabababbaba
40.	bbababbabababbababa ⇒ abababbabababbababb
41.	babababbabababababbabbbbb ⇒ abbabababbababababa
42.	babababbababababbababbb ⇒ abbabababbababababba
43.	bababbababababababbabbbbbbbbbbb ⇒ abbababbabababababa
44.	bababbabababababbababbbbbbbbb ⇒ abbababbabababababba
45.	bababbababababbabababbbbbb ⇒ abbababbababababbaba
46.	bababbabababbabababab ⇒ aabababbabababbaba
47.	babbabababbababababab ⇒ aabababbababababba
48.	bbabababababbababababbbbbbbbbbbb ⇒ aabababababbababa
49.	bbababababbabababababbbbbbbbb ⇒ aababababbabababa
50.	bbabababbababababababbbbbb ⇒ aabababbababababa
51.	bbababbabababababababbb ⇒ aababbabababababa
52.	bbababbababababababbabbb ⇒ aababbabababababba
53.	bbababbabababababbababbb ⇒ aababbababababbaba
54.	bbababbababababbabababbb ⇒ aababbabababbababa
55.	babababbabababababbababbbbbb ⇒ abbabababbabababababba
56.	babababbababababbabababbb ⇒ abbabababbababababbaba
57.	bababbababababbababababbbbbb ⇒ abbababbababababbababa
58.	babbababababbabababababbbbbbb ⇒ aababababbababababba
59.	bbabababbabababababababbbbbb ⇒ aabababbabababababa
60.	bbabababbababababababbabbbbbb ⇒ aabababbabababababba
61.	bbababbababababababababbb ⇒ aababbababababababa
62.	bbababbabababababababbabbb ⇒ aababbababababababba
63.	bbababbababababababbababbb ⇒ aababbabababababbaba
64.	bbababbabababababbabababbb ⇒ aababbababababbababa
65.	bbababbababababbabababa ⇒ ababababbababababbababb
66.	bbababbababababbababababbb ⇒ aababbabababbabababa
67.	abbababbababababbabababa ⇒ aababababbababababbababb
68.	babbabababbababababbababab ⇒ aababbabababbababababba
69.	bbababbabababababababababbb ⇒ aababbabababababababa
70.	bbabababbababababbababababab ⇒ abababbababababbaba
	...

Collecting factors up to length 7, frequency 2:

Length 2:	[2/0] ba, [2/1] bb
Length 3:	[3/0] bba, [3/1] bbb
Length 4:	[4/0] baba, [4/1] abba
Length 5:	[5/0] bbaba, [5/1] babba
Length 6:	[6/0] bababa, [6/1] ababab

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

Step 2

Checking up to 80 rules for overlaps.

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

Rewriting system is not complete: wordLimit

#	Rule
1.	bbbc ⇒ cbbb
2.	cccb ⇒ b
3.	cccbb ⇒ bb
4.	cccbbb ⇒ bbb
5.	bccc ⇒ b
6.	cccc ⇒ c
7.	cccbc ⇒ bc
8.	cccbbc ⇒ bbc
9.	acccbc ⇒ abc
10.	bbaccc ⇒ bba
11.	bbba ⇒ abbb
12.	ca ⇒ bacbbbbb
13.	bcba ⇒ abbc
14.	aab ⇒ baccbbb
15.	aac ⇒ baccbbc
16.	ababbb ⇒ bc
17.	abacbbb ⇒ bcc
18.	abaccbb ⇒ ccc
19.	abaccbbb ⇒ b
20.	abaccbbc ⇒ c
21.	abbac ⇒ bba
22.	baa ⇒ bbaccbb
23.	bbaba ⇒ c
24.	aaa ⇒ 1
	...

Collecting factors up to length 14, frequency 1:

Length 2:	[2/0] bb
Length 3:	[3/0] bbb
Length 4:	[4/0] cbbb
Length 5:	[5/0] abacc
Length 6:	[6/0] baccbb
Length 7:	[7/0] baccbbc
Length 8:	[8/0] bacbbbbb

Considering [length 5 / frequency 0] abacc=d.

Step 3

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

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