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:

[2/0]	ba	22047	`lf:536,lp:24,ls:7,rf:419,rs:61,lprs:21,a:2`
[2/1]	bb	3645	`lf:425,lp:44,ls:56,rf:115,rs:5,lprs:3,a:2`
[3/0]	bba	10327	`lf:151,lp:43,ls:4,rf:109,rs:20,lprs:10,a:2`
[3/1]	bbb	10274	`lf:218,lp:1,ls:53,rf:1,rs:1,lprs:10,a:4`
[4/0]	baba	11683	`lf:361,lp:18,ls:3,rf:261,rs:40,lprs:11,a:6`
[4/1]	abba	2258	`lf:107,lp:1,ls:3,rf:109,rp:18,rs:20,lsrp:2,a:2`
[5/0]	bbaba	8271	`lf:129,lp:42,rf:88,rs:12,lprs:8,a:6`
[5/1]	babba	5225	`lf:106,lp:5,ls:3,rf:91,rs:20,lprs:5,a:2`
[6/0]	bababa	2395	`lf:214,lp:6,ls:3,rf:145,rs:27,lprs:2,a:7`
[6/1]	ababab	1365	`lf:211,ls:5,rf:145,rp:3,rs:1,lsrp:1,a:7`

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(a) = deg(c) = 1, a < c

Rewriting system is not complete: roundsLimit

#	Rule
1.	bbba ⇒ abbb
2.	bbbc ⇒ cbbb
3.	ababbb ⇒ bc
4.	baa ⇒ abbabb
5.	bbaba ⇒ c
6.	bbabba ⇒ aab
7.	ca ⇒ bacbbbbb
8.	cbabbb ⇒ bbabbc
9.	cbbabbbbb ⇒ abc
10.	bcba ⇒ abbc
11.	aaa ⇒ 1
12.	aaba ⇒ cbbabb
13.	aabba ⇒ bbac
14.	ababbabbb ⇒ bcbba
15.	aabc ⇒ babbb
16.	abacbbb ⇒ bcc
17.	ababbcbbb ⇒ bcbbc
18.	abbac ⇒ bba
19.	acbbabb ⇒ ba
20.	abcbba ⇒ ccbbbbbb
21.	bbacba ⇒ aac
22.	bbacbba ⇒ ab
23.	accbbb ⇒ babba
24.	bbacc ⇒ abba
25.	cbacbbb ⇒ bbabbcc
26.	cbbac ⇒ babbabbbbb
27.	cbbabbcbbb ⇒ abcc
28.	ccbba ⇒ baccb
29.	cccb ⇒ b
30.	bccc ⇒ b
31.	ababbabbc ⇒ bccba
32.	abbabbcbbabb ⇒ baba
33.	babacbba ⇒ accb
34.	abaccbb ⇒ ccc
35.	abacbcbbb ⇒ bccbc
36.	abacbbcbbb ⇒ bccbbc
37.	ababbccbbb ⇒ bcbbcc
38.	babacc ⇒ abaccb
39.	acbbabc ⇒ bababa
40.	abccba ⇒ ccbbcbbb
41.	bbacbbcbbabb ⇒ ababa
42.	accbc ⇒ babbcbbabb
43.	accbbc ⇒ bacba
44.	baccc ⇒ ba
45.	cbacbba ⇒ babbabbccb
46.	cbacc ⇒ bacbbab
47.	cbbabbccbb ⇒ accc
48.	bcbbabbcc ⇒ acbba
49.	ccbabbabb ⇒ baccba
50.	bccbaba ⇒ abacbbc
51.	bbccbabbab ⇒ accbabb
52.	bccbbcbbabb ⇒ acba
53.	cccc ⇒ c
54.	abaccba ⇒ bbccbacbb
55.	aaccc ⇒ baccbb
56.	abacbccbbb ⇒ bccbcc
57.	accbabba ⇒ bbccbac
58.	accbabbc ⇒ bacbaba
59.	babbccbacbb ⇒ acc
60.	cbbabbccbc ⇒ ababa
61.	bccbabbabc ⇒ acbaba
62.	bbccbacba ⇒ accbac
63.	bbccbbccbacb ⇒ acc
	...

Collecting factors up to length 14 / frequency 1:

[2/0]	bb	5194	`lf:90,lp:11,ls:21,rf:53,rp:6,rs:13,lsrp:2,lprs:3,a:2`
[3/0]	bbb	20053	`lf:17,lp:2,ls:13,rf:14,rs:7,lprs:20,a:6`
[4/0]	ccba	1022	`lf:11,lp:1,ls:2,rf:6,rs:2,lprs:1,a:53`
[5/0]	abacc	10008	`lf:3,lp:2,ls:1,rf:1,rp:1,lsrp:10,a:93`
[6/0]	cbbabb	23	`lf:9,lp:4,ls:4,rf:2,rp:1,rs:2,re:1,a:22`
[7/0]	bbccbac	10	`lf:3,lp:1,rf:2,rp:2,rs:1,re:1,a:148`
[8/0]	bbcbbabb	8	`lf:3,ls:3,rf:1,rs:1,a:31`
[9/0]	bbccbacbb	6	`lf:1,ls:1,rf:1,rp:1,rs:1,re:1,a:153`
[10/0]	babbcbbabb	6	`lf:1,ls:1,rf:1,rp:1,rs:1,re:1,a:31`
[11/0]	bbccbbccbac	2	`lf:1,lp:1,a:289`

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(a) = deg(c) = 1, a < c

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