Morphocompletion for #5196 ⟨a, b | aababba=abab⟩

Solved by morph:2/0,2/0,4/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.	aababba ⇒ abab
2.	aaababbbab ⇒ ababbba
3.	ababbabba ⇒ aababbbab
4.	ababababba ⇒ ababbab
5.	ababbababba ⇒ ababbbab
6.	aababababbbab ⇒ ababbbabba
7.	ababaababbbab ⇒ ababbabbba
8.	aababbbabbba ⇒ ababababbbab
9.	ababbabababba ⇒ ababbabbab
	...

Collecting factors up to length 7 / frequency 3:

[2/0]	ab	42	`lf:34,lp:5,ls:3,rf:28,rp:8,rs:6,lprp:4,lsrp:3,lprs:4`
[2/1]	ba	37	`lf:31,ls:6,rf:22,rs:3`
[2/2]	bb	18	`lf:18,rf:17`
[3/0]	bab	27	`lf:24,ls:3,rf:19,rs:6`
[3/1]	aba	23	`lf:18,lp:5,rf:11,rp:8,lprp:4`
[3/2]	bba	19	`lf:13,ls:6,rf:11,rs:3`
[4/0]	abab	22	`lf:17,lp:5,rf:11,rp:8,rs:1,re:1,lprp:4`
[4/1]	babb	13	`lf:13,rf:11`
[4/2]	abba	13	`lf:8,ls:5,rf:5,rs:1`
[5/0]	ababb	14	`lf:11,lp:3,rf:8,rp:6,lprp:2`
[5/1]	babba	13	`lf:8,ls:5,rf:5,rs:1`
[5/2]	ababa	8	`lf:6,lp:2,rf:2,rp:1,a:1`
[6/0]	ababba	14	`lf:7,lp:3,ls:4,rf:3,rp:3,lprp:1,lsrp:2`
[6/1]	abbbab	7	`lf:4,ls:3,rf:4,rs:3,a:4`
[6/2]	babbba	6	`lf:5,ls:1,rf:6,rs:2,a:4`

Considering [length 2 / frequency 0] ab=c.

Step 2

Checking up to 20 rules for overlaps.

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

Rewriting system is not complete: roundsLimit

#	Rule
1.	ab ⇒ c
2.	accba ⇒ cc
3.	accccba ⇒ ccb
4.	ccbc ⇒ ccccba
5.	aaccccccbac ⇒ ccccccbaa
6.	aaaaccaccccccbac ⇒ ccccccbaaa
7.	ccccccbaca ⇒ aaccaccccccbac
8.	ccccccbaaca ⇒ aaaaccaccaccccccbac
9.	ccccccbacca ⇒ aaccaccaccccccbac
10.	ccbb ⇒ accccccba
11.	aaccaccccccbacb ⇒ ccccccbacc
12.	aaccaccaccccccbacb ⇒ ccccccbaccc
13.	ccccbacba ⇒ accccccbac
14.	ccccccbaacba ⇒ aaccccccccbac
15.	ccccbacccba ⇒ accccccbacb
16.	ccccccbaacccba ⇒ aaccccccccbacb
17.	ccccbacbc ⇒ accccccbacb
18.	ccccccbaacbc ⇒ aaccccccccbacb
19.	ccbaccccccbac ⇒ accccccbacccccbaa
20.	ccccbacbb ⇒ ccbaccccccba
	...

Collecting factors up to length 6 / frequency 5:

[2/0]	cc	96	`lf:83,lp:13,rf:104,rp:8,rs:3,re:1,lprp:2,a:2`
[2/1]	cb	31	`lf:29,ls:2,rf:24,rs:5,a:2`
[2/2]	ac	31	`lf:26,lp:2,ls:3,rf:29,rp:5,rs:5,lsrp:1,a:2`
[2/3]	ba	28	`lf:22,ls:6,rf:19,rs:3,a:2`
[2/4]	aa	14	`lf:10,lp:4,rf:12,rp:6,rs:3,lprs:2,a:10`
[3/0]	ccc	66	`lf:56,lp:10,rf:76,rp:5,rs:1,a:3`
[3/1]	cba	28	`lf:22,ls:6,rf:19,rs:3,a:2`
[3/2]	ccb	25	`lf:22,lp:3,rf:20,rp:2,rs:1,re:1,a:2`
[3/3]	acc	16	`lf:14,lp:2,rf:20,rp:5,rs:1,a:2`
[3/4]	bac	15	`lf:12,ls:3,rf:13,rs:5,a:6`
[4/0]	cccc	48	`lf:38,lp:10,rf:57,rp:5,a:3`
[4/1]	ccba	25	`lf:20,lp:1,ls:4,rf:19,rp:1,rs:3,a:2`
[4/2]	cccb	18	`lf:18,rf:18,a:3`
[4/3]	cbac	15	`lf:12,ls:3,rf:13,rs:5,a:6`
[4/4]	accc	9	`lf:8,lp:1,rf:14,rp:5,rs:1,a:3`
[5/0]	ccccc	28	`lf:22,lp:6,rf:39,rp:4,a:5`
[5/1]	cccba	21	`lf:18,ls:3,rf:18,rs:3,a:3`
[5/2]	ccccb	20	`lf:16,lp:4,rf:18,rp:1,a:3`
[5/3]	ccbac	16	`lf:12,lp:1,ls:3,rf:13,rp:1,rs:5,a:6`
[5/4]	cbacb	7	`lf:5,ls:2,rf:4,rs:4,a:6`

Considering [length 2 / frequency 0] cc=d.

Step 3

Checking up to 20 rules for overlaps.

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

Rewriting system is not complete: roundsLimit

#	Rule
1.	dc ⇒ cd
2.	cc ⇒ d
3.	ab ⇒ c
4.	adba ⇒ d
5.	addba ⇒ db
6.	adbd ⇒ ddba
7.	aaddbd ⇒ dddbaa
8.	ddbda ⇒ aadaddbd
9.	dbc ⇒ ddba
10.	ddbac ⇒ dbd
11.	dddbaac ⇒ aadddbad
12.	dbb ⇒ adddba
13.	aadaddbdb ⇒ dddbad
14.	aadadaddbdb ⇒ ddbdd
15.	dbdba ⇒ addbd
16.	dbddba ⇒ addbdb
17.	dbdbd ⇒ adaddbdb
	...

Collecting factors up to length 6 / frequency 5:

[2/0]	db	26	`lf:19,lp:5,ls:2,rf:15,rp:2,rs:3,re:1,lprs:2,a:3`
[2/1]	bd	12	`lf:9,ls:3,rf:6,rs:3,a:6`
[2/2]	dd	12	`lf:9,lp:3,rf:16,rp:5,rs:1,a:6`
[2/3]	ad	12	`lf:9,lp:3,rf:10,rp:4,rs:2,a:3`
[2/4]	ba	10	`lf:6,ls:4,rf:6,rs:3,a:3`
[3/0]	dbd	15	`lf:9,lp:3,ls:3,rf:6,rp:1,rs:3,re:1,lprs:1,a:6`
[3/1]	dba	10	`lf:6,ls:4,rf:6,rs:3,a:3`
[3/2]	ddb	10	`lf:8,lp:2,rf:11,rp:3,a:6`
[3/3]	bdb	6	`lf:4,ls:2,rf:2,rs:2,a:11`
[3/4]	aad	6	`lf:3,lp:3,rf:2,rp:2,a:14`
[4/0]	dbdb	8	`lf:4,lp:2,ls:2,rf:2,rs:2,lprs:1,a:11`
[4/1]	ddba	7	`lf:4,lp:1,ls:2,rf:6,rp:2,rs:3,re:2,a:6`
[4/2]	ddbd	6	`lf:4,lp:1,ls:1,rf:5,rp:1,rs:2,lprs:1,a:11`
[4/3]	addb	5	`lf:4,lp:1,rf:4,rp:2,a:9`
[4/4]	aada	4	`lf:2,lp:2,rf:1,rp:1,a:19`
[5/0]	ddbdb	4	`lf:2,ls:2,rf:2,rs:2,a:12`
[5/1]	addbd	4	`lf:3,ls:1,rf:4,rp:2,rs:2,re:1,a:11`
[5/2]	aadad	4	`lf:2,lp:2,rf:1,rp:1,a:19`
[5/3]	bddba	2	`lf:1,ls:1,a:13`
[5/4]	dbddb	2	`lf:1,lp:1,a:13`

Considering [length 4 / frequency 0] dbdb=e.

Step 4

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

Rewriting system is complete. See ⟨a, b | aababba=abab⟩.