There is one more example of a 15-bit largest common subsequence:

Mersenne exponent #47 = 43112609 = 1010010001[B][COLOR=red]110110001010000[/COLOR][/B]1[SUB]2[/SUB], and
Mersenne exponent #49 = 74207281 = 1000[COLOR=Red][B]110110001010000[/B][/COLOR]00110001[SUB]2[/SUB].

There are 5 examples of 13-bit largest common subsequences:

Mersenne exponent #28 = 86243 = 1010[COLOR=Red][B]1000011100011[/B][/COLOR][SUB]2[/SUB], and
Mersenne exponent #51 = 82589933 = 10011101[COLOR=red][B]1000011100011[/B][/COLOR]101101[SUB]2[/SUB];

Mersenne exponent #30 = 132049 = 100[B][COLOR=red]0000011110100[/COLOR][/B]01[SUB]2[/SUB], and
Mersenne exponent #48 = 57885161 = 110111001101[B][COLOR=red]0000011110100[/COLOR][/B]1[SUB]2[/SUB];

Mersenne exponent #32 = 756839 = 10111[COLOR=Red][B]0001100011001[/B][/COLOR]11[SUB]2[/SUB], and
Mersenne exponent #42 = 25964951 = 11000110[B][COLOR=red]0001100011001[/COLOR][/B]0111[SUB]2[/SUB];

Mersenne exponent #34 = 1257787 = 100110[B][COLOR=red]0110001001110[/COLOR][/B]11[SUB]2[/SUB], and
Mersenne exponent #41 = 24036583 = 10110111[B][COLOR=red]0110001001110[/COLOR][/B]0111[SUB]2[/SUB]; and

Mersenne exponent #47 = 43112609 = 101001000[B][COLOR=red]1110110001010[/COLOR][/B]0001[SUB]2[/SUB], and
Mersenne exponent #50 = 77232917 = 1001001101001[B][COLOR=red]1110110001010[/COLOR][/B]1[SUB]2[/SUB].

There are 5 examples of 12-bit largest common subsequences:

Mersenne exponent #17 = 2281 = [B][COLOR=red]100011101001[/COLOR][/B][SUB]2[/SUB], and
Mersenne exponent #33 = 859433 = 110[B][COLOR=red]100011101001[/COLOR][/B]01001[SUB]2[/SUB];

Mersenne exponent #38 = 6972593 = 1101010011[B][COLOR=red]001001011000[/COLOR][/B]1[SUB]2[/SUB], and
Mersenne exponent #44 = 32582657 = 111110[B][COLOR=red]001001011000[/COLOR][/B]0000001[SUB]2[/SUB];

Mersenne exponent #41 = 24036583 = 1011[B][COLOR=red]011101100010[/COLOR][/B]011100111[SUB]2[/SUB], and
Mersenne exponent #47 = 43112609 = 10100100[B][COLOR=red]011101100010[/COLOR][/B]100001[SUB]2[/SUB];

Mersenne exponent #46 = 42643801 = 1010001010[B][COLOR=red]101100010101[/COLOR][/B]1001[SUB]2[/SUB], and
Mersenne exponent #50 = 77232917 = 100100110100111[B][COLOR=red]101100010101[/COLOR][/B][SUB]2[/SUB]; and

Mersenne exponent #49 = 74207281 = 1000[B][COLOR=red]110110001010[/COLOR][/B]00000110001[SUB]2[/SUB], and
[FONT=&quot]Mersenne exponent #50 = 77232917 = 10010011010011[B][COLOR=red]110110001010[/COLOR][/B]1[SUB]2[/SUB].[/FONT]

There are 6 examples of 11-bit largest common subsequences:

Mersenne exponent #19 = 4253 = 10[B][COLOR=red]00010011101[/COLOR][/B][SUB]2[/SUB], and
Mersenne exponent #34 = 1257787 = 100110011[B][COLOR=red]00010011101[/COLOR][/B]1[SUB]2[/SUB];

Mersenne exponent #25 = 21701 =[B][COLOR=red] 10101001100[/COLOR][/B]0101[SUB]2[/SUB], and
Mersenne exponent #38 = 6972593 = 1[B][COLOR=red]10101001100[/COLOR][/B]10010110001[SUB]2[/SUB];

Mersenne exponent #41 = 24036583 = 10110[B][COLOR=red]11101100010[/COLOR][/B]011100111[SUB]2[/SUB], and
Mersenne exponent #50 = 77232917 = 1001001101001[B][COLOR=red]11101100010[/COLOR][/B]101[SUB]2[/SUB];

Mersenne exponent #46 = 42643801 = 1010001010[B][COLOR=red]10110001010[/COLOR][/B]11001[SUB]2[/SUB], and
Mersenne exponent #47 = 43112609 = 10100100011[B][COLOR=red]10110001010[/COLOR][/B]0001[SUB]2[/SUB];

Mersenne exponent #46 = 42643801 = 1010001010[B][COLOR=red]10110001010[/COLOR][/B]11001[SUB]2[/SUB], and
Mersenne exponent #49 = 74207281 = 10001[B][COLOR=red]10110001010[/COLOR][/B]00000110001[SUB]2[/SUB]; and

Mersenne exponent #47 = 43112609 = 1010010[B][COLOR=red]00111011000[/COLOR][/B]10100001[SUB]2[/SUB], and
[FONT=&quot]Mersenne exponent #51 = 82589933 = 1[B][COLOR=red]00111011000[/COLOR][/B]011100011101101[SUB]2[/SUB].[/FONT]

Also, there are:

- 19 examples of 10-bit LCSs;
- 56 examples of 9-bit LCSs;
- 103 examples of 8-bit LCSs;
- 166 examples of 7-bit LCSs;
- 229 examples of 6-bit LCSs;
- 235 examples of 5-bit LCSs;
- 145 examples of 4-bit LCSs;
- 142 examples of 3-bit LCSs;
- 146 examples of 2-bit LCSs; and
- 16 examples of 1-bit LCSs.

This is for the total of 1275 = (51×51-51)/2 = 2+5+5+6+19+56+103+166+229+235+145+142+146+16 ([I]i[/I], [I]j[/I]) pairs.

Let's investigate the largest common subsequences when the bits of one of the exponents are [COLOR=Red][B]reversed[/B][/COLOR] (using the Wolfram function [COLOR=Blue]IntegerReverse[/COLOR] for [I]base[/I] = 2 ) so that the bit sequence is presented in reversed order and the least significant bit (LSB) becomes the most significant bit (MSB).
The result is shown in the attached 3D image.

The largest common subsequence contains 14 bits:
Mersenne exponent #37 = 3021377 = 1011100001101001000001[SUB]2[/SUB], with [COLOR=Red][B]reversed[/B][/COLOR] bits 100[COLOR=Red][B]00010010110000[/B][/COLOR]11101[SUB]2[/SUB], and
Mersenne exponent #44 = 32582657 = 11111[COLOR=red][B]00010010110000[/B][/COLOR]000001[SUB]2[/SUB].

There are:

- 1 example of 14-bit LCSs;
- 4 examples of 12-bit LCSs;
- 9 examples of 11-bit LCSs;
- 14 examples of 10-bit LCSs;
- 59 examples of 9-bit LCSs;
- 102 examples of 8-bit LCSs;
- 173 examples of 7-bit LCSs;
- 229 examples of 6-bit LCSs;
- 230 examples of 5-bit LCSs;
- 154 examples of 4-bit LCSs;
- 139 examples of 3-bit LCSs;
- 145 examples of 2-bit LCSs; and
- 16 examples of 1-bit LCSs.

This is for the total of 1275 = (51×51-51)/2 = 1+4+9+14+59+102+173+229+230+154+139+145+16 ([I]i[/I], [I]j[/I]) pairs.

For completeness, let’s count the [B][COLOR=red]cyclic[/COLOR][/B] largest common subsequences for pairs of exponents of Mersenne primes for which the binary sequences of the exponents are folded in a closed loop.

There are 3 cyclic largest common subsequences of bit length = 16 bits:

Mersenne exponent #28 = 86243 = [B][COLOR=red]101[/COLOR][/B]0[B][COLOR=red]1000011100011[/COLOR][/B][SUB]2[/SUB], and
Mersenne exponent #51 = 82589933 = 10011101[B][COLOR=red]1000011100011101[/COLOR][/B]101[SUB]2[/SUB];

Mersenne exponent #34 = 1257787 = [B][COLOR=red]100110[/COLOR][/B]01100[B][COLOR=red]0100111011[/COLOR][/B][SUB]2[/SUB], and
Mersenne exponent #48 = 57885161 = [B][COLOR=red]11011100110[/COLOR][/B]1000001111[B][COLOR=red]01001[/COLOR][/B][SUB]2[/SUB]; and

Mersenne exponent #46 = 42643801 = 1010001010[B][COLOR=red]1011000101011001[/COLOR][/B][SUB]2[/SUB], and
Mersenne exponent #50 = 77232917 = [B][COLOR=red]1001[/COLOR][/B]00110100111[B][COLOR=red]101100010101[/COLOR][/B][SUB]2[/SUB].
[code]
Bit length, Cyclic LCS count
1, 4
2, 40
3, 92
4, 131
5, 136
6, 212
7, 237
8, 177
9, 126
10, 55
11, 27
12, 17
13, 10
14, 5
15, 3
16, 3[/code]Let’s also count the [B][COLOR=red]cyclic[/COLOR][/B] largest common subsequences for pairs of exponents of Mersenne primes when the bits of one of the exponents are [B][COLOR=red]reversed[/COLOR][/B][COLOR=black].[/COLOR]

There is one cyclic largest common subsequence of bit length = 17 bits:

Mersenne exponent #44 = 32582657 = 1111100010010110000000001[SUB]2[/SUB], with [B][COLOR=red]reversed[/COLOR][/B] bits 100000[B][COLOR=red]00001101001000111[/COLOR][/B]11[SUB]2[/SUB], and
Mersenne exponent #47 = 43112609 = [B][COLOR=red]101001000111[/COLOR][/B]011000101[B][COLOR=red]00001[/COLOR][/B][SUB]2[/SUB].
[code]
Bit length, Cyclic LCS count when the bits of one of the exponents are reversed
1, 4
2, 40
3, 93
4, 128
5, 142
6, 217
7, 225
8, 177
9, 131
10, 56
11, 33
12, 18
13, 5
14, 4
15, 1
16, 0
[FONT=&quot]17, 1[/FONT][/code][FONT=&quot]
[/FONT]

Let's consider the LCS set of all base-2 largest common subsequences between the exponents of the first [I]n[/I] known Mersenne primes.
A concatenation between LCSs can be attempted to construct the exponent of the next known Mersenne prime #([I]n[/I]+1).
[U]Bit reversal and cyclic operations are allowed.[/U]
The exhaustive computations show that no such concatenation of up to 3 (or even 4) LCSs can be performed for all odd exponents of known Meresenne primes, 1 < [I]n[/I] ≤ 51.
Such concatenations do exist for many exponents but not for all of them.

Therefore, a new LCS between the next exponent #([I]n[/I]+1) and one of the [I]n[/I] preceding exponents has to be selected.
Then all odd exponents #([I]n[/I]+1) of known Mersenne primes can be represented as [B]a concatenation of a new LCS and [COLOR="Red"]no more than two[/COLOR] other LCSs[/B] from the LCS set of the preceding exponents of the first [I]n[/I] known Mersenne primes.

Here is an illustration concerned with the previous post #19 at [URL]https://www.mersenneforum.org/showpost.php?p=615770&postcount=19[/URL].

The exponent 521 = 1000001001[SUB]2[/SUB] of M13 is used as an example.

The LCS set of the preceding 12 exponents is:

{1, 10, 11, 011, 100, 101, 111, 1001, 1011, 1101, 1111, 11111}[SUB]2[/SUB].

No LCS concatenation can construct the exponent of M13 because of 5 consecutive 0s.

One has to select a suitable new LCS from the LCSs between the exponent of M13 and the preceding 12 exponents:

(1, 10, 010, 1000, 1001}[SUB]2[/SUB].

Selecting the new LCS 1000[SUB]2[/SUB] and using bit reversal for 100[SUB]2[/SUB] gives the following LCS construct:

{1000, 001, 001}[SUB]2[/SUB].

Below is the [COLOR=Red][B]LCS set[/B][/COLOR] related to post #16 at [URL]https://www.mersenneforum.org/showpost.php?p=615384&postcount=16[/URL].
It contains [COLOR=Red][B]311[/B][/COLOR] distinct LCSs for all 51 exponents of known Mersenne primes.
Some LCSs occur more than one time for the total of [B][COLOR=Blue]1275[/COLOR][/B] ([I]i[/I], [I]j[/I]) pairs in post #16.
[code]
1
10
11
010
011
100
101
110
111
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111
00010
00011
00101
00110
00111
01000
01001
01010
01011
01100
01101
01110
01111
10000
10001
10010
10011
10100
10101
10110
10111
11000
11001
11010
11011
11100
11101
11110
11111
000010
000011
000101
001001
001100
001101
001110
001111
010001
010011
010100
010110
010111
011000
011001
011010
011011
011101
011110
011111
100000
100001
100010
100011
100101
100110
100111
101000
101001
101010
101011
101100
101101
101110
101111
110001
110010
110011
110100
110101
110110
110111
111000
111010
111100
111101
111110
111111
0000010
0000011
0000111
0001001
0001101
0001110
0010010
0010011
0010100
0010111
0011000
0011001
0011011
0011100
0011101
0011110
0100000
0100101
0100110
0100111
0101000
0101001
0101111
0110000
0110001
0110101
0110111
0111000
0111011
0111100
0111101
0111111
1000001
1000101
1000110
1000111
1001001
1001011
1001100
1001101
1001111
1010000
1010001
1010011
1010100
1010101
1010110
1011000
1011001
1011100
1011101
1011110
1100001
1100010
1100011
1100110
1100111
1101001
1101010
1101011
1101100
1101101
1101110
1110001
1110011
1110100
1111000
1111100
1111111
00000011
00001001
00001101
00010011
00011011
00100101
00110000
00110001
00110010
00110011
00110100
00110110
00111011
00111101
01001000
01010000
01010101
01011000
01011111
01100000
01100010
01101001
01101011
01110011
01110100
01111011
01111111
10000000
10000011
10001001
10001010
10010010
10010111
10011000
10011001
10011010
10011011
10011101
10011110
10100000
10100100
10101001
10101011
10101101
10101111
10110000
10110001
10110101
10110111
10111000
10111100
11000011
11001100
11001101
11010001
11010010
11010011
11010101
11011000
11011101
11100001
11100110
11100111
11101001
11101100
11110100
000110001
001001101
001011111
001101001
001101101
010010001
010011101
010100001
010101011
010110001
010111111
011000011
011000101
011011110
011100011
011100111
011101100
011111110
100000001
100010011
100011101
100100101
100110100
100111011
101000000
101000111
101001000
101001100
101011111
101100010
110000110
110001001
110010010
110011010
110100100
110100111
111001101
111010001
111010010
111011000
111101001
0000110001
0001001110
0100011101
0100111011
0110100111
0111011000
0111100110
1000101000
1000110110
1001100010
1001111111
1010011000
1010101010
1011010101
1011011101
1011101100
1101100010
1101110011
00010011101
00111011000
10101001100
10110001010
11101100010
001001011000
011101100010
100011101001
101100010101
110110001010
0000011110100
0001100011001
0110001001110
1000011100011
1110110001010
110101111101001
110110001010000

[/code]

Below is the [B][COLOR="Red"]LCS set[/COLOR][/B] related to post #17 at [url]https://mersenneforum.org/showpost.php?p=615423&postcount=17[/url] when the bits of one of the exponents in each pair ([I]i[/I], [I]j[/I]) are [B][COLOR="Red"]reversed[/COLOR][/B] so that its bit sequence is presented in a reversed order and the least significant bit (LSB) becomes the most significant bit (MSB).
It contains [B][COLOR="red"]311[/COLOR][/B] distinct LCSs for all 51 exponents of known Mersenne primes.
Some LCSs occur more than once for the total of [B][COLOR="Blue"]1275[/COLOR][/B] ([I]i[/I], [I]j[/I]) pairs in post #17.
[code]
1
10
11
010
011
100
101
110
111
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111
00010
00011
00100
00101
00110
00111
01000
01001
01010
01011
01100
01101
01110
01111
10000
10001
10010
10011
10100
10101
10110
10111
11001
11010
11011
11100
11101
11110
11111
000010
000011
000101
000110
000111
001001
001010
001100
001101
001110
001111
010001
010010
010011
010100
010101
010110
010111
011000
011001
011010
011011
011100
011101
011110
011111
100000
100001
100010
100011
100101
100110
100111
101000
101001
101010
101011
101100
101101
101110
101111
110000
110001
110010
110011
110100
110101
110110
110111
111000
111001
111010
111101
111111
0000010
0000011
0000101
0000110
0000111
0001001
0001101
0010010
0010011
0010100
0010111
0011000
0011001
0011011
0011100
0011101
0011110
0011111
0100000
0100011
0100100
0100110
0101000
0101001
0101011
0101111
0110001
0110011
0110101
0110111
0111011
0111100
0111101
0111111
1000000
1000001
1000010
1000101
1000110
1000111
1001000
1001001
1001011
1001100
1001101
1001110
1001111
1010000
1010001
1010010
1010100
1010101
1010110
1011000
1011001
1011100
1011111
1100001
1100010
1100011
1100100
1100110
1100111
1101001
1101010
1101011
1101100
1101101
1101110
1110000
1110001
1110011
1110100
1111010
1111111
00001001
00011010
00011011
00011101
00100101
00100110
00101100
00101111
00110110
00110111
00111011
01000111
01001100
01011001
01011111
01100111
01101001
01101110
01110001
01111001
01111111
10000000
10000010
10001001
10001101
10001110
10010001
10010010
10010111
10011000
10011001
10011011
10011101
10100011
10100100
10101000
10101010
10101101
10101111
10110001
10110101
10111000
10111011
11000001
11000101
11001001
11001011
11010010
11010011
11010100
11010101
11010110
11011001
11011101
11011110
11100001
11100110
11100111
11101000
11101001
11111010
000000011
000000101
000001011
000001101
000011011
000101000
001100000
001100111
010010001
010100011
010111100
011000000
011010101
011011101
011100011
011100111
011101001
011110011
011111110
100001110
100011000
100011011
100011101
100101100
100101110
100101111
100110001
100110011
100110101
100111011
101001100
101011111
101101110
101110001
101110110
101111001
110000110
110001001
110100100
110110001
110110101
110111001
111010011
111011001
111101000
0110101010
1000001001
1000110000
1000110011
1000110110
1001001011
1001011111
1001110111
1001111111
1011100011
1011110000
1100111011
00010100011
00101110110
00110001100
00110111100
01011111010
10100110001
11010011000
11010101010
000110100100
011100001101
101010111111
111000100101
00001101001000[/code]
[code]
(* Wolfram code *)
MpData = {2, 3, 5, 7, 13, 17, 19, 31, 61, 89, 107, 127, 521, 607, 1279, 2203, 2281, 3217, 4253, 4423, 9689, 9941, 11213, 19937, 21701, 23209, 44497, 86243, 110503, 132049, 216091, 756839, 859433, 1257787, 1398269, 2976221, 3021377, 6972593, 13466917, 20996011, 24036583, 25964951, 30402457, 32582657, 37156667, 42643801, 43112609, 57885161, 74207281, 77232917, 82589933};
nMp = Length[MpData]; LCSa = ConstantArray[0, nMp*(nMp - 1)/2]; base = 2; count = 0;
ic = 0; While[ic < nMp, ic++; intlen1 = Length[IntegerDigits[MpData[[ic]], base]]; s1 = IntegerDigits[MpData[[ic]], base, intlen1];
jc = 0; While[jc < nMp, jc++; If[ic < jc, intlen2 = Length[IntegerDigits[MpData[[jc]], base]]; s2 = IntegerDigits[IntegerReverse[MpData[[jc]],base], base, intlen2];
cs = LongestCommonSubsequence[s1, s2];
If[cs != {}, fd = cs; mc = 1; kc = 0; While[kc < count, kc++; If[LCSa[[kc]] == fd, mc = 0;];]; If[mc == 1, count++; LCSa[[count]] = fd;];];
];];];
lcs = ConstantArray[0, count]; kc = 0; While[kc < count, kc++; lcs[[kc]] = LCSa[[kc]];]; lcs = Sort[lcs];
kc = 0; While[kc < count, kc++; Print[IntegerString[lcs[[kc]], base]];]; Print[count];
[/code]