Morphocompletion for #10660 ⟨a, b | aaaa=bab, bbbb=1⟩

Solved by morph:3/0,13/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.	bab ⇒ aaaa
3.	abaab ⇒ bbaaaaaaaaa
4.	aaaabbaaaa ⇒ baab
5.	bbbaaaa ⇒ ab
6.	aaaabbb ⇒ ba
7.	aaaabbaabaaaaa ⇒ baabaaab
8.	aaaabbaaabaaaaa ⇒ baabaaaab
9.	bbbb ⇒ 1
10.	bbbaabaaaaa ⇒ abaaab
11.	bbbaaabaaaaa ⇒ abaaaab
12.	abaaabbb ⇒ bbbaaaba
13.	aaaabbaabbaaaaa ⇒ baabaaabb
14.	aaaabbaabaaabaaaaa ⇒ baabaaabaaab
15.	aaaabbaabaaaabaaaaa ⇒ baabaaabaaaab
16.	aaaabbaaabbaaaaa ⇒ baabaaaabb
17.	aaaabbaaabaaabaaaaa ⇒ baabaaaabaaab
18.	aaaabbaaabaaaabaaaaa ⇒ baabaaaabaaaab
19.	bbbaabbaaaaa ⇒ abaaabb
20.	bbbaabaaabaaaaa ⇒ abaaabaaab
21.	bbbaabaaaabaaaaa ⇒ abaaabaaaab
22.	bbbaaabbaaaaa ⇒ abaaaabb
23.	bbbaaabaaabaaaaa ⇒ abaaaabaaab
24.	bbbaaabaaaabaaaaa ⇒ abaaaabaaaab
25.	aaaabbaabbaaba ⇒ baabaaabaaaabb
26.	aaaabbaabbaaabaaaaa ⇒ baabaaabbaaab
27.	aaaabbaabbaaaabaaaaa ⇒ baabaaabbaaaab
28.	aaaabbaabaaabbaaaaa ⇒ baabaaabaaabb
29.	aaaabbaaabbaaba ⇒ baabaaaabaaaabb
30.	aaaabbaaabbaaabaaaaa ⇒ baabaaaabbaaab
31.	aaaabbaaabbaaaabaaaaa ⇒ baabbaabb
32.	aaaabbaaabaaabbaaaaa ⇒ baabaaaabaaabb
33.	bbbaabbaaba ⇒ abaaabaaaabb
34.	bbbaabbaaabaaaaa ⇒ abaaabbaaab
35.	bbbaabbaaaabaaaaa ⇒ abaaabbaaaab
36.	bbbaabaaabbaaaaa ⇒ abaaabaaabb
37.	bbbaabaaabaaabaaaaa ⇒ abaaabaaabaaab
38.	bbbaabaaabaaaabaaaaa ⇒ abaaabaaabaaaab
39.	bbbaaabbaaba ⇒ abaaaabaaaabb
40.	bbbaaabbaaabaaaaa ⇒ abaaaabbaaab
41.	bbbaaabbaaaabaaaaa ⇒ abbaabb
42.	bbbaaabaaabbaaaaa ⇒ abaaaabaaabb
43.	abaaabbaabbb ⇒ bbbaabbaaaba
44.	abaaabbaaabbb ⇒ bbbaabbaaaaba
45.	abaaabaaabbaaaabb ⇒ bbaaaabbaaabaaaba
46.	abaaaabbaabbb ⇒ bbbaaabbaaaba
47.	abaaaabbaaabbb ⇒ bbbaaabbaaaaba
48.	aaaabbaabbbaaba ⇒ baabaaabbaaaabb
49.	aaaabbaabbaabbaaaaa ⇒ baabaaabbaabb
50.	aaaabbaabbaaabbaaaaa ⇒ baabaaabbaaabb
51.	aaaabbaaabbbaaba ⇒ baabbaabbb
52.	aaaabbaaabbbaaaba ⇒ baabbaaabbb
53.	aaaabbaaabbaabbaaaaa ⇒ baabaaaabbaabb
54.	bbbaabbbaaba ⇒ abaaabbaaaabb
55.	bbbaabbaabbaaaaa ⇒ abaaabbaabb
56.	bbbaabbaaabbaaaaa ⇒ abaaabbaaabb
57.	bbbaabaaabbaaba ⇒ abaaabaaabaaaabb
58.	bbbaabaaaabbaaba ⇒ abaaabaaaabaaaabb
59.	bbbaaabbbaaba ⇒ abbaabbb
60.	bbbaaabbbaaaba ⇒ abbaaabbb
61.	bbbaaabbaabbaaaaa ⇒ abaaaabbaabb
62.	bbbaaabbaaabbaaaaa ⇒ abaaaabbaaabb
63.	bbbaaabbaaaabaaabaaaaa ⇒ abbaabbaaab
64.	bbbaaabaaabbaaba ⇒ abaaaabaaabaaaabb
65.	abbaabbaabbb ⇒ bbbaaabbaaaabaaaba
66.	abbaabbaaabbb ⇒ bbbaaabbaaaabaaaaba
67.	abbaabaaabbaaaabb ⇒ bbbaaabbaaabaaaba
68.	bbbaabbaaabbaaba ⇒ abaaabbaaabaaaabb
69.	bbbaaabbaaaabbaaba ⇒ abbaabbaaaabb
70.	abbaabbbaabbb ⇒ bbbaaabbaaaabbaaaba
71.	abbaabbbaaabbb ⇒ bbbaaabbbaabba
72.	abbaaabbbaaabbb ⇒ bbbaaabbbaaabba
73.	abaaabbaaabbaabbb ⇒ bbbaabbaaabbaaaba
74.	abaaabbaaaabbaaabbb ⇒ bbbaabbbaabba
75.	bbbaabbaabbbaaba ⇒ abaaabbaabbaaaabb
76.	bbbaaabbbaabbaab ⇒ abbaabbbaaabbaaaa
77.	bbbaaabbbaabbaaaba ⇒ abbaaabbaabbb
78.	bbbaaabbbaabbaaaaba ⇒ abbaaabbaaabbb
79.	bbbaaabbbaaabbaaaba ⇒ abbaaaabbaabbb
80.	bbbaaabbbaabbbaaaba ⇒ abbaaabbbaabbb
	...

Collecting factors up to length 7 / frequency 2:

[2/0]	bb	38469	`lf:227,lp:39,ls:16,rf:135,rp:15,rs:37,lsrp:14,lprs:24,a:1`
[2/1]	ba	5464	`lf:217,lp:1,ls:20,rf:185,rp:25,rs:15,re:1,lsrp:5`
[3/0]	bbb	18169	`lf:69,lp:39,ls:14,rf:26,rp:13,rs:8,lsrp:12,lprs:6,a:1`
[3/1]	aba	15229	`lf:74,lp:9,ls:20,rf:88,rp:27,rs:11,lsrp:8,lprs:7,a:7`
[4/0]	abba	2159	`lf:88,lp:6,rf:52,rp:10,rs:3,lprs:2,a:5`
[4/1]	aaaa	1249	`lf:122,lp:25,ls:40,rf:56,rp:1,rs:4,re:1,lprs:1`
[5/0]	aaaaa	10086	`lf:39,lp:1,ls:38,rf:6,rs:2,lprs:10,a:2`
[5/1]	aaaab	4123	`lf:43,lp:24,ls:1,rf:46,rs:9,lprs:4,a:2`
[6/0]	aaaabb	4093	`lf:31,lp:24,ls:2,rf:22,rs:14,lprs:4,a:3`
[6/1]	abbaab	1060	`lf:35,lp:5,ls:1,rf:14,rp:5,lsrp:1,a:11`

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

Rewriting system is not complete: arenaTotalLimit

#	Rule
1.	aaaaab ⇒ baaaaa
2.	caaaa ⇒ ab
3.	aaaac ⇒ ba
4.	bab ⇒ aaaa
5.	abaab ⇒ bbaaaaaaaaa
6.	aaaabbaaaa ⇒ baab
7.	bc ⇒ 1
8.	bac ⇒ aaaabb
9.	cb ⇒ 1
10.	cab ⇒ bbaaaa
11.	caaba ⇒ abaac
12.	caaaba ⇒ abaaac
13.	cc ⇒ bb
14.	bbb ⇒ c
15.	aaaabbaabaaaaa ⇒ baabaaab
16.	aaaabbaaabaaaaa ⇒ baabaaaab
17.	baabaac ⇒ aaaabbaaba
18.	baabaaac ⇒ aaaabbaaaba
19.	caabba ⇒ abaacaaac
20.	caaabba ⇒ abaaacaaac
21.	bbaaaabb ⇒ cac
22.	aaaabbaabbaaaaa ⇒ baabaaabb
23.	aaaabbaabaaabaaaaa ⇒ baabaaabaaab
24.	aaaabbaaabbaaaaa ⇒ baabaaaabb
25.	baabaaabaac ⇒ aaaabbaabaaaba
26.	baabaaabaaac ⇒ aaaabbaabaaaaba
27.	baabaaaabaac ⇒ aaaabbaaabaaaba
28.	baabaaaabaaac ⇒ aaaabbaaabaaaaba
29.	abaacaaacaaac ⇒ caaca
30.	abaaacaaacaaac ⇒ caaaca
31.	aaacaaacaaacaab ⇒ baacaaacaaacaaa
32.	acacaaacaaac ⇒ caaacaaacaca
33.	acaacaaacaaac ⇒ caaacaaacaaca
34.	acaaacaaacaaac ⇒ caaacaaacaaaca
35.	aaacaaacaaacaca ⇒ baacaaacaaac
36.	aaacaaacaaacaaca ⇒ baaacaaacaaac
37.	bbaaaabaaaabb ⇒ cacac
38.	aaaabbaabbaaba ⇒ baabaaabaaaabb
39.	aaaabbaaabbaaba ⇒ baabaaaabaaaabb
40.	aaaabbaaabbaaaabaaaaa ⇒ baabbaabb
41.	baabaaabbaac ⇒ aaaabbaabbaaaba
42.	baabaaabbaaac ⇒ aaaabbaabbaaaaba
43.	baabaaaabbaac ⇒ aaaabbaaabbaaaba
44.	baabaaaabbaaac ⇒ aaaabbaaabbaaaaba
45.	abaaabbaaacaaac ⇒ caacaca
46.	abaaaabbaaacaaac ⇒ caaacaca
47.	abbaacaaacaaac ⇒ caaacaaca
48.	abbaaacaaacaaac ⇒ caaacaaaca
49.	abaacaaacaaabb ⇒ caacac
50.	abaaacaaacaaabb ⇒ caaacac
51.	caaacaaacacac ⇒ acacaaacaaabb
52.	caaacaaacaacac ⇒ acaacaaacaaabb
53.	caaacaaacaaacac ⇒ acaaacaaacaaabb
54.	bbaaaabaaaabaaaabb ⇒ cacacac
55.	abbaabbaaacaaac ⇒ caaacacaca
56.	abbaaabbaaacaaac ⇒ caaacaacaca
57.	abaaabbaaaabaaacaaac ⇒ caacacaca
58.	abaaabbaaacaaabb ⇒ caacacac
59.	abaaaabbaaacaaabb ⇒ caaacacac
60.	abbaacaaacaaabb ⇒ caaacaacac
61.	abbaaacaaacaaabb ⇒ caaacaaacac
62.	abaaabaacaaacaacaaac ⇒ cacaacaca
63.	abaaabaaacaaacaacaaac ⇒ cacaaacaca
64.	abaaaabaacaaacaacaaac ⇒ caacaacaca
65.	abaaacacaaacaaabb ⇒ caacaacac
66.	abaaacaacaaacaaabb ⇒ caacaaacac
67.	cacacaaacaaabb ⇒ bbaaacaaacacac
68.	cacaacaaacaaabb ⇒ bbaaacaaacaacac
69.	abbaabbaaacaaabb ⇒ caaacacacac
70.	abbaaabbaaacaaabb ⇒ caaacaacacac
71.	abaacaacacaaacaaabb ⇒ cacaacaacac
	...

Collecting factors up to length 14 / frequency 1:

[2/0]	ba	12203	`lf:98,lp:12,ls:6,rf:61,rp:14,rs:11,re:1,lsrp:2,lprs:10`
[3/0]	aca	3189	`lf:79,lp:3,ls:2,rf:87,rp:3,rs:15,lprs:3,a:16`
[4/0]	aaac	2144	`lf:73,lp:3,ls:21,rf:42,rs:5,lprs:2,a:8`
[5/0]	aaaaa	10022	`lf:7,lp:1,ls:6,rf:6,rs:2,lprs:10,a:6`
[6/0]	aaaabb	3058	`lf:16,lp:9,ls:3,rf:14,rp:11,rs:4,re:1,lprs:3,a:7`
[7/0]	aaacaaa	1063	`lf:41,lp:3,rf:18,rs:1,lprs:1,a:21`
[8/0]	aaacaaac	2060	`lf:28,lp:3,ls:12,rf:14,rs:3,lprs:2,a:21`
[9/0]	caaacaaac	4042	`lf:15,lp:3,ls:7,rf:10,rp:5,rs:2,lsrp:4,a:24`
[10/0]	acaaacaaac	28	`lf:12,lp:1,ls:7,rf:5,rp:1,rs:2,a:24`
[11/0]	aaacaaacaaa	1017	`lf:9,lp:3,rf:4,rs:1,lprs:1,a:29`
[12/0]	aaacaaacaaac	1016	`lf:7,lp:3,ls:3,rf:2,rs:1,lprs:1,a:29`
[13/0]	caaacaaacaaac	10006	`lf:2,lp:1,ls:1,rf:1,rp:1,lsrp:10,a:87`

Considering [length 13 / frequency 0] caaacaaacaaac=d.

Step 3

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

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