Morphocompletion for #11071 ⟨a, b | baab=aaa, bbbb=1⟩

Solved by morph:3/0,6/0,7/0. (See Morphocompletion.)

Step 1

Checking up to 80 rules for overlaps.

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

Rewriting system is not complete: roundsLimit

#	Rule
1.	aaaaab ⇒ baaaaa
2.	baab ⇒ aaa
3.	aabaaaab ⇒ bbaaaaaaaa
4.	aaabbaaa ⇒ baaaab
5.	bbbaaa ⇒ aab
6.	aababaaaab ⇒ bbaaabaaaaaaaa
7.	aaabbb ⇒ baa
8.	aaabbabaaaaa ⇒ baaaabaaab
9.	bbbb ⇒ 1
10.	bbbabaaaaa ⇒ aabaaab
11.	aababbb ⇒ bbbabaa
12.	aabababaaaab ⇒ bbaaabaaabaaaaaaaa
13.	aaabbabbaaaaa ⇒ baaaabaaabb
14.	aaabbababaaaaa ⇒ baaaabaaabab
15.	aaabbabaaabaaaaa ⇒ baaaabaaabaaab
16.	aaabbabaaaab ⇒ baaaababbaaa
17.	bbbabbaaaaa ⇒ aabaaabb
18.	bbbababaaaaa ⇒ aabaaabab
19.	bbbabaaabaaaaa ⇒ aabaaabaaab
20.	bbbabaaaab ⇒ aababbaaa
21.	aababbaaabb ⇒ bbbababaa
22.	aabababbb ⇒ bbaaabbabaa
23.	aaabbabbabaaaaa ⇒ baaaabaaabbab
24.	aaabbabbaaabaaaaa ⇒ babaaaababb
25.	aaabbabbaaaabaa ⇒ baaaabaaabaaabb
26.	aaabbababbaaaaa ⇒ baaaabaaababb
27.	aaabbabababaaaaa ⇒ baaaabaaababab
28.	aaabbababaaaab ⇒ baaaababbaaabaaa
29.	bbbabbabaaaaa ⇒ aabaaabbab
30.	bbbabbaaabaaaaa ⇒ aabbaaaabb
31.	bbbabbaaaabaa ⇒ aabaaabaaabb
32.	bbbababbaaaaa ⇒ aabaaababb
33.	bbbabababaaaaa ⇒ aabaaababab
34.	bbbababaaabaaaaa ⇒ aabaaababaaab
35.	bbbababaaaab ⇒ aababbaaabaaa
36.	bbbabaaababaaaaa ⇒ aabaaabaaabab
37.	aababbaaabaaabb ⇒ bbbabababaa
38.	aabababbaaabb ⇒ bbaaabbababaa
39.	aababababbb ⇒ bbaaabaaabbabaa
40.	aabaaabbabbb ⇒ bbbabbaaabaa
41.	aaabbabbbabaa ⇒ baaaabbabbb
42.	aaabbabbabbaaaaa ⇒ baaaabaaabbabb
43.	aaabbabbabaaaabaa ⇒ babaaaabababb
44.	bbbabbbabaa ⇒ aabbabbb
45.	bbbabbabbaaaaa ⇒ aabaaabbabb
46.	bbbabbababaaaaa ⇒ aabaaabbabab
47.	bbbabbabaaaabaa ⇒ aabbaaaababb
48.	bbbabbaaababaaaaa ⇒ aabbaaaabbab
49.	bbbababbabaaaaa ⇒ aabaaababbab
50.	bbbababbaaaabaa ⇒ aabaaababaaabb
51.	bbbabababbaaaaa ⇒ aabaaabababb
52.	bbbababababaaaaa ⇒ aabaaabababab
53.	abbbabbaaabaaabaa ⇒ baaaababbabbb
54.	aabbaaaabbabbb ⇒ bbbabbaaabaaabaa
55.	aababaaabbabbb ⇒ bbaaabbabbaaabaa
56.	aabaaabbabbaaabb ⇒ bbbabbaaababaa
57.	aabaaabbababbb ⇒ bbbabbabaaabaa
58.	aabaaababbabbb ⇒ bbbababbaaabaa
59.	aaabbabbbababaa ⇒ baaaabbabbaaabb
60.	bbbabbbababaa ⇒ aabbabbaaabb
61.	bbbabbabbabaaaaa ⇒ aabaaabbabbab
62.	bbbabbababbaaaaa ⇒ aabaaabbababb
63.	bbbabbaaabbabaa ⇒ aabbababbb
64.	bbbababbabbaaaaa ⇒ aabaaababbabb
65.	aabbabbbabbb ⇒ bbbabbbabbaa
66.	aaabbabbbabbabaaaa ⇒ babababbbaa
67.	aaabbabbbabbaaabaa ⇒ bababbaa
68.	bbbabbbabbaaabaa ⇒ aabbaaabbabbb
69.	bbbabbbabbaaaab ⇒ aabbabbbabbaaa
70.	abbbabbbabbabaaaa ⇒ bababbbaa
71.	aabbaaabbabbbabbaaa ⇒ aabbbabab
72.	abbbabbbabbababaa ⇒ bababbaaabb
73.	abbbabbbabbaaabbaa ⇒ babbbaa
74.	bbbabbbabbbabbaa ⇒ aabbbabbbabbb
75.	abbbabbbabbaaababbaa ⇒ babbabbaa
76.	abbbabbbabbbababbaa ⇒ bbabbaa
77.	aabbbabbbabbbabbabaa ⇒ abbbabaa
78.	abbbabbbabbbababbbaa ⇒ bbabbbaa
	...

Collecting factors up to length 5 / frequency 1:

[2/0]	aa	52716	`lf:297,lp:38,ls:53,rf:263,rp:33,rs:32,lprp:1,lsrp:29,lprs:23,lsrs:8`
[3/0]	bbb	10157	`lf:74,lp:32,ls:11,rf:25,rp:9,rs:6,lsrp:6,lprs:4,a:1`
[4/0]	aaab	3169	`lf:59,lp:19,ls:9,rf:76,rs:6,lprs:3,a:2`

Considering [length 3 / frequency 0] bbb=c.

Step 2

Checking up to 80 rules for overlaps.

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

Rewriting system is not complete: arenaTotalLimit

#	Rule
1.	aaaaac ⇒ caaaaa
2.	baa ⇒ aaac
3.	aab ⇒ caaa
4.	caaac ⇒ aa
5.	aacc ⇒ cacaaa
6.	aaacac ⇒ ccaa
7.	cb ⇒ 1
8.	bc ⇒ 1
9.	bacaaa ⇒ aaacab
10.	bb ⇒ cc
11.	ccc ⇒ b
12.	cacacaaa ⇒ aac
13.	baccaa ⇒ aaacaacac
14.	bacacaaa ⇒ ccaac
15.	bacaacaaa ⇒ aaacabab
16.	cacaccaaaaa ⇒ aacaac
17.	cacacaacaaa ⇒ aacab
18.	acacacacaa ⇒ aa
19.	acacacaacaa ⇒ bacaa
20.	aacacacac ⇒ cacacacaa
21.	aacaacacac ⇒ cacacaacaa
22.	baccacaaa ⇒ aaacaacacab
23.	bacaccaa ⇒ aaacabacac
24.	bacacaacaaa ⇒ ccaacab
25.	bacaacacaaa ⇒ aaacabacc
26.	bacaacaacaaa ⇒ aaacababab
27.	cacaccacaaaaa ⇒ aacaacac
28.	cacaccaacaaaaa ⇒ aacaacaac
29.	cacaccaaaacaaa ⇒ aacaacab
30.	cacacaccaa ⇒ aacacac
31.	cacacaacacaaa ⇒ aacacc
32.	cacacaacaacaaa ⇒ aacabab
33.	accacacacaa ⇒ cacacacaaca
34.	acacaccaaaacaa ⇒ babacaa
35.	acacacaacacaa ⇒ bacacaa
36.	aacacaacacaca ⇒ aacacab
37.	cacacabacaa ⇒ aacacaacacac
38.	aacabacacac ⇒ cacacaacacaa
39.	baccaccaa ⇒ aaacaacacaacac
40.	bacaccacaaa ⇒ aaacabacacab
41.	bacacaccaa ⇒ ccaacacac
42.	bacacaacacaaa ⇒ ccaacacc
43.	bacacaacaacaaa ⇒ ccaacabab
44.	bacaacaccaa ⇒ aaacababacac
45.	bacaacacaca ⇒ acacacaacab
46.	cacaccaccaaaaa ⇒ aacaacacc
47.	cacacaccacaaa ⇒ aacacacab
48.	cacacaacaccaa ⇒ aacabacac
49.	cacacaacacaacaaa ⇒ aacaccab
50.	cacacaacaacacaaa ⇒ aacabacc
51.	acacaccaccaaaa ⇒ babacacaa
52.	acacaccacaaaacaa ⇒ baccacaa
53.	cacacacaacab ⇒ acaacacaca
	...

Collecting factors up to length 7 / frequency 1:

[2/0]	aa	34287	`lf:118,lp:8,ls:38,rf:78,rp:29,rs:14,re:2,lprp:1,lsrp:27,lprs:7,lsrs:6,a:9`
[3/0]	cac	7164	`lf:88,lp:16,ls:4,rf:42,rp:5,rs:9,lsrp:3,lprs:4,a:15`
[4/0]	caca	1119	`lf:66,lp:16,ls:2,rf:29,rp:5,rs:1,lprs:1,a:17`
[5/0]	aaaaa	10012	`lf:5,lp:1,ls:4,rf:1,rs:1,lprs:10,a:18`
[6/0]	cacaca	1048	`lf:21,lp:11,ls:2,rf:9,rp:4,rs:1,lprs:1,a:20`

Considering [length 6 / frequency 0] cacaca=d.

Step 3

Checking up to 80 rules for overlaps.

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

Rewriting system is not complete: roundsLimit

#	Rule
1.	aaaaad ⇒ daaaaa
2.	daaad ⇒ aa
3.	aadd ⇒ dadaaa
4.	aaadad ⇒ ddaa
5.	dddaa ⇒ aaad
6.	dadadaaa ⇒ aad
7.	adadadaa ⇒ ddda
8.	dddadaaaaa ⇒ aaadaaaad
9.	dadaddaaaaa ⇒ aadaad
10.	daadadada ⇒ daddd
11.	adddda ⇒ aa
12.	adadadad ⇒ dadadada
13.	ddddda ⇒ da
14.	ddddada ⇒ ada
15.	dddaddaa ⇒ aaadaadad
16.	dadddd ⇒ da
17.	dadadaddaa ⇒ aadadad
18.	addadadada ⇒ ddddad
19.	adadaddadaaa ⇒ dddadd
20.	ddddadda ⇒ adda
21.	dddaddd ⇒ adadaddaaa
22.	aadadaddadadad ⇒ dadadadda
23.	caa ⇒ ddda
24.	cda ⇒ adadadda
25.	cada ⇒ dddda
26.	cdda ⇒ adadaddda
27.	cadda ⇒ da
28.	cddda ⇒ adadaa
29.	caddda ⇒ dda
30.	cdddda ⇒ adadada
31.	aac ⇒ daa
32.	dca ⇒ cad
33.	dac ⇒ daadadad
34.	aadc ⇒ dddda
35.	dadc ⇒ ddadadada
36.	daddc ⇒ daddadadad
37.	dadddc ⇒ ddadadaddadaa
38.	baa ⇒ adaa
39.	bda ⇒ adda
40.	bada ⇒ adada
41.	bdda ⇒ addda
42.	badda ⇒ adadda
43.	bddda ⇒ aa
44.	baddda ⇒ adaddda
45.	bdddda ⇒ ada
46.	abd ⇒ dadaaa
47.	aab ⇒ aaad
48.	dbd ⇒ dadd
49.	dab ⇒ daad
50.	aadb ⇒ aadad
51.	dadb ⇒ dadad
52.	daddb ⇒ daddad
53.	dadddb ⇒ dadddad
54.	dddaddb ⇒ dddaddad
55.	acaca ⇒ bd
56.	daddcc ⇒ daddadad
57.	cb ⇒ 1
58.	bc ⇒ 1
59.	bb ⇒ cc
60.	ccc ⇒ b
	...

Collecting factors up to length 8 / frequency 1:

[2/0]	aa	19114	`lf:33,lp:8,ls:10,rf:37,rp:11,rs:12,re:3,lprp:2,lsrp:6,lprs:13,lsrs:1,a:10`
[3/0]	dad	8128	`lf:40,lp:11,ls:3,rf:52,rp:11,rs:11,lprp:5,lsrp:2,lprs:6,a:47`
[4/0]	adda	1033	`lf:9,lp:1,ls:3,rf:11,rp:2,rs:5,re:2,lsrp:1,lsrs:2,a:71`
[5/0]	aaaaa	10008	`lf:3,lp:1,ls:2,rf:1,rs:1,lprs:10,a:63`
[6/0]	adadad	32	`lf:9,lp:3,ls:2,rf:11,rp:4,rs:3,a:130`
[7/0]	dadadad	11015	`lf:4,lp:1,ls:2,rf:5,rp:2,rs:1,lsrp:11,a:170`

Considering [length 7 / frequency 0] dadadad=e.

Step 4

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

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