Morphocompletion for #5375 ⟨a, b | ababbba=baba⟩

Solved by morph:6/1,2/1,5/0. (See Morphocompletion.)

Step 1

Checking up to 20 rules for overlaps.

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

Rewriting system is not complete: rulesLimit

#	Rule
1.	ababbba ⇒ baba
2.	ababbbbaba ⇒ babbaba
3.	ababbbbbaba ⇒ babbbaba
4.	ababbbbbbaba ⇒ babbbbaba
5.	ababbbbabbaba ⇒ babbabbaba
6.	ababbbbbbbaba ⇒ babbbbbaba
	...

Collecting factors up to length 7 / frequency 3:

[2/0]	bb	24	`lf:24,rf:12`
[2/1]	ba	24	`lf:18,ls:6,rf:18,rp:6,rs:6,lsrp:6,lsrs:6`
[2/2]	ab	24	`lf:18,lp:6,rf:12`
[3/0]	aba	22	`lf:11,lp:6,ls:5,rf:6,rs:6,lprs:6,lsrs:5`
[3/1]	bbb	17	`lf:17,rf:6`
[3/2]	bab	12	`lf:12,rf:12,rp:6`
[4/0]	abab	12	`lf:6,lp:6`
[4/1]	bbbb	11	`lf:11,rf:3,a:1`
[4/2]	baba	10	`lf:5,ls:5,rf:6,rp:1,rs:6,re:1,lsrs:5`
[5/0]	ababb	12	`lf:6,lp:6`
[5/1]	bbaba	10	`lf:5,ls:5,rf:5,rs:5,lsrs:5,a:1`
[5/2]	bbbbb	6	`lf:6,rf:1,a:3`
[6/0]	ababbb	12	`lf:6,lp:6`
[6/1]	bbbaba	8	`lf:4,ls:4,rf:3,rs:3,lsrs:3,a:1`
[6/2]	bbbbab	5	`lf:5,rf:2,a:1`

Considering [length 6 / frequency 1] bbbaba=c.

Step 2

Checking up to 20 rules for overlaps.

Auxiliary generators:
1. c = bbbaba
Reduction order:
- Right-to-left recursive path with deg(a) = deg(c) = 0, a < c; deg(b) = 1

Rewriting system is not complete: roundsLimit

#	Rule
1.	bcba ⇒ cc
2.	baabac ⇒ abacba
3.	bcabac ⇒ ccbaba
4.	ababcc ⇒ bacba
5.	cbbba ⇒ bc
6.	bababa ⇒ abac
7.	ababbc ⇒ bac
8.	bcababc ⇒ ccbbaba
9.	babbac ⇒ abacbbc
10.	bcbbac ⇒ ccbabbc
11.	bbabac ⇒ cba
12.	ababbba ⇒ baba
13.	bbbaba ⇒ c
14.	babbaba ⇒ ababc
15.	ababbbc ⇒ babc
16.	bbababc ⇒ cbabbba
17.	bbbbac ⇒ cbbc
18.	ababbbbc ⇒ babbc
19.	bbbbabc ⇒ cbbbc
20.	bbbbabbc ⇒ cbbbbc
	...

Collecting factors up to length 6 / frequency 5:

[2/0]	ba	40	`lf:30,lp:4,ls:6,rf:20,rp:5,rs:7,lsrp:1,lprs:1,lsrs:1`
[2/1]	bb	33	`lf:27,lp:6,rf:12`
[2/2]	ab	30	`lf:25,lp:5,rf:12,rp:4`
[2/3]	bc	23	`lf:12,lp:4,ls:7,rf:9,rp:1,rs:9,re:1,lprs:1,lsrs:4,a:3`
[2/4]	ac	12	`lf:6,ls:6,rf:5,rs:2,a:2`
[3/0]	aba	22	`lf:14,lp:5,ls:3,rf:7,rp:4,rs:3,lsrp:2,lprs:1`
[3/1]	bab	20	`lf:17,lp:3,rf:8,rp:3`
[3/2]	bbb	16	`lf:12,lp:4,rf:4`
[3/3]	bba	15	`lf:11,lp:2,ls:2,rf:2,rs:1,lprs:1`
[3/4]	bac	12	`lf:6,ls:6,rf:5,rp:2,rs:2,re:1,a:2`
[4/0]	abab	13	`lf:8,lp:5,rf:1,rp:1`
[4/1]	baba	10	`lf:6,lp:1,ls:3,rf:3,rp:1,rs:3,re:1`
[4/2]	bbba	9	`lf:6,lp:1,ls:2,rf:1,rs:1`
[4/3]	babb	9	`lf:7,lp:2,rf:3,rp:1`
[4/4]	bbab	8	`lf:6,lp:2,rf:1,a:1`
[5/0]	bbaba	8	`lf:4,lp:2,ls:2,rf:1,rs:1,a:1`
[5/1]	ababb	8	`lf:4,lp:4`
[5/2]	bbbba	6	`lf:3,lp:3,a:21`
[5/3]	ababc	6	`lf:3,lp:1,ls:2,rf:1,rp:1,rs:1,re:1,a:8`
[5/4]	bbbab	4	`lf:3,lp:1,a:1`

Considering [length 2 / frequency 1] bb=d.

Step 3

Checking up to 20 rules for overlaps.

Auxiliary generators:
1. c = bbbaba
2. d = bb
Reduction order:
- Right-to-left recursive path with deg(a) = deg(c) = 0, a < c; deg(d) = 1; deg(b) = 2

Rewriting system is not complete: roundsLimit

#	Rule
1.	ddac ⇒ cdc
2.	ddadc ⇒ cddc
3.	ddadac ⇒ ccdc
4.	ddaddc ⇒ cdddc
5.	ddaba ⇒ cdba
6.	bc ⇒ cdba
7.	cdbac ⇒ dcba
8.	dabac ⇒ cba
9.	ddaabac ⇒ ccba
10.	bd ⇒ db
11.	cdbadc ⇒ ddbac
12.	dabadc ⇒ dbac
13.	badac ⇒ abacdc
14.	bb ⇒ d
15.	dbaba ⇒ c
16.	abadba ⇒ baba
17.	cdbadba ⇒ dc
18.	babac ⇒ dababa
19.	babadc ⇒ dac
20.	bababa ⇒ abac
	...

Collecting factors up to length 6 / frequency 5:

[2/0]	ba	29	`lf:20,lp:4,ls:5,rf:13,rp:1,rs:7,lsrp:1,lprs:1,lsrs:2,a:3`
[2/1]	ac	14	`lf:7,ls:7,rf:5,rs:4,a:7`
[2/2]	dd	13	`lf:7,lp:6,rf:4,rp:1,a:8`
[2/3]	da	12	`lf:10,lp:2,rf:2,rp:2,a:8`
[2/4]	ab	11	`lf:10,lp:1,rf:5,rp:2,a:3`
[3/0]	aba	14	`lf:10,lp:1,ls:3,rf:5,rp:2,rs:2,lsrp:1,lprs:1,a:3`
[3/1]	dda	12	`lf:6,lp:6,a:8`
[3/2]	dba	9	`lf:6,lp:1,ls:2,rf:4,rp:1,rs:2,a:3`
[3/3]	bab	8	`lf:5,lp:3,rf:2,rp:1,a:3`
[3/4]	bac	8	`lf:4,ls:4,rf:4,rs:3,a:7`
[4/0]	baba	10	`lf:5,lp:3,ls:2,rf:2,rp:1,rs:2,re:1,lprs:1,a:3`
[4/1]	badc	6	`lf:3,ls:3,a:24`
[4/2]	abac	6	`lf:3,ls:3,rf:2,rp:2,rs:1,re:1,a:7`
[4/3]	daba	6	`lf:3,lp:2,ls:1,rf:1,rp:1,a:8`
[4/4]	cdba	6	`lf:3,lp:3,rf:2,rp:2,rs:2,re:2,a:6`
[5/0]	badba	4	`lf:2,ls:2,a:3`
[5/1]	abadc	4	`lf:2,ls:2,a:24`
[5/2]	cdbad	4	`lf:2,lp:2,a:10`
[5/3]	babab	2	`lf:1,lp:1,a:7`
[5/4]	babad	2	`lf:1,lp:1,a:24`

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

Step 4

Auxiliary generators:
1. c = bbbaba
2. d = bb
3. e = badba
Reduction order:
- Right-to-left recursive path with deg(a) = deg(e) = deg(c) = 0, a < e < c; deg(d) = 1; deg(b) = 2

Rewriting system is complete. See ⟨a, b | ababbba=baba⟩.