Repunits, decimal numbers that are all ones

Document A

Catching Your Interest, or Not

Imagine a long number, an integer. Very long. 194 digits long! That is a long number, yes. In fact, the number of atoms in the known universe is a number only 80 digits long.

We choose our imagined number, 194 digits long, to be a number that can be multiplied up from smaller integers. This is not surprising, the number 10000017 can be multiplied up from 3*3*13*31*79*349. (Thanks to web site Wolfram Alpha, "factors 10000017".) For our 194-digit number, let's not worry about just which numbers it multiplies up from. But let's make a particular, 194-digit number to be made from all ones.

By the way, these all-ones integers are called repunits, and they are in the domain of recreational mathematicians. Which I am not, but I have curiosity.

If we look at https://stdkmd.net/nrr/repunit/tm.cgi?p=2, Mr. Kamada's computer has figured that our number = 11 × 12004721 × 102527361354613106010527<24> × 323338434891034089173475790125293<33> × 846035731396919233767211537899097169<36> × 27422699366054621683295623079471066588881<41> × 109399846855370537540339266842070119107662296580348039<54>. This is seven factors.

I will tell you that if we carefully choose certain of these factors and multiply them, we get a product of

1093998468553705375403392668420701191076622965803480390000000000000000000000000000000000000000000109399846855370537540339266842070119107662296580348039 You see the string of zeros in the exact center, and you see 109399846855370537540339266842070119107662296580348039

at both the beginning and end. This is a bizarre number that no one would expect, but it indeed is a product of some of the seven factors of our 194-digit, all-ones numbers. And since our number is the product of all seven factors, we can multiply our bizarre factor by the other factors and come up exactly to our 194-digit, all-ones number.

If we use a Python program to try lots of multiplies of various factors of our number, we will at some point find a product of

10913382727272727272727272727272727272727272727272727272727272727272727272727272727272727272727273818611. And we can even find the most bizarre factor, 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001, which is 98 digits.

It is very strange that such a plain number, 194 ones, would have factors that are so showy. But this is how all-ones numbers go. This web page explores these numbers. We will return to the 194-digit number, later.

And Before We Get Into the Repunits,

why this web page is so long--

John Engelbrecht is appending the web page as I am discovering additional things. So there are some sidelines that are being written up, and I don't pare down to the essentials. But as I review this web page, I see that there are important points all up and down, so I don't want to pare down.

In particular, the two Python programs have been instrumental in having insights. 1) Using the web page of Mr. Kamada, which has all the factors of hundreds of thousands of repunits, one can see all the factors of any repunit. But being able to multiply factors in various orders (all orders) and look for patterns, automatically, required the first Python program. 2) Mimicking the way people do long multiplication is the second Python program.

Very Long Repunits (all-ones numbers) with Assistance from the Ruby Coding Language

This web page is linked from 1966 Physics Time Line. The section in the Time Line, 1900-1990, is getting too clogged up with repunits, so I am starting up this sub-page.

R657, the decimal integer with 657 ones

Looking at https://stdkmd.net/nrr/repunit/ , and specifically

https://stdkmd.net/nrr/repunit/tm.cgi?p=7 ,

the 657-digit repunit, which is 657 ones, is interesting because it has a probably-prime factor that is 432 digits long. This factor is merely hinted at my Mr. Kamada, who gives only the beginning of the factor:

9990000009... This long factor is only 34.15% factored by the world-wide network of recreational mathematicians.

(The entire Repunit-657 entry from Mr. Kamada's web page is:

R657 = (10657-1)/9 = 1111111111...<657> = 32 × 37 × 439 × 333667 × 2212293763<10> × 12171337159<11> × 1855193842151350117<19> × 49207341634646326934001739482502131487446637<44> × 39316310783659104892252157287077969239619734325044334592964583271<65> × 23593748551050409936688015200253053030029532433958916533719315706853<68> × [9990000009...<432>] (34.15%) )

I had selected this repunit because I was looking at the 7th page of Kamada's web site, searching for patterns of 999000 which tend to be interesting.

Since my installation of Ruby on computer GRID can do arbitrary-precision math, I took the data from Kamada's web page and did some math, partly to get the whole, 432-digit factor, to see if there are repeating digits in it.

Ruby code (underscores are markers allowed by Ruby, the underscores are not part of the number) than translates from the yellow, above, to full numbers without abbreviations.

j657=1111111111_1111111111_1111111111_1111111111_1111111111_1111111111_1111111111_1111111111_1111111111_1111111111_1111111111_1111111111_1111111111_

1111111111_1111111111_1111111111_1111111111_1111111111_1111111111_1111111111_1111111111_1111111111_1111111111_1111111111_1111111111_1111111111_

1111111111_1111111111_1111111111_1111111111_1111111111_1111111111111_1111111111_1111111111_1111111111_1111111111_1111111111_1111111111_1111111111_

1111111111_11111111111111111111_1111111111_1111111111_1111111111_1111111111_1111111111_1111111111_1111111111_1111111111_11111111111111111111_

1111111111_1111111111_1111111111_1111111111_1111111111_1111111111_1111111111_1111111111_11111111111111111111_1111111111_1111111111_1111111111_1111

k = 9*37*439*333667*2212293763 * 12171337159 # the smallest prime factors from Mr. Kamada's web page

k1 = 1855193842151350117 # start the longer prime factors, 4 of them

k3 = 49207341634646326934001739482502131487446637

k2 = 39316310783659104892252157287077969239619734325044334592964583271

m = 23593748551050409936688015200253053030029532433958916533719315706853

puts j657/k/k1/k3/k2/m # if you divide the 657-digit number by all but the 432-digit mystery factor, you should get the 432-digit number

puts "above supposed to be 432 digits and may not be prime" # , set it equal to n

n = 999000000999000000999000000999000000999000000999000000999000000999000000999000000999000000999000000999000000999000000999000000999000000999000000 999000000999000000999000000999000000999000000999000000999000000999000000_999999000999999000999999000999999000999999000999999000999999000

999999000999999000999999000999999000999999000999999000999999000999999000999999000999999000999999000999999000999999000999999000999999000999999000999999001

#preceding n is copied from the output area, this should be the mystery 432-digit factor of the 657-digit repunit. It is amazing how Ruby can keep track of these big numbers. Bear in mind this fact, the number of atoms in the universe is a number with only 80 digits!

# n starts 3 9s 6 0s ends 6 9s 3 0s and a 999999001 as bold-coded just above. As suspected, the 432-digit factor has a strong pattern, a common feature of factors of repunits. But also note that the smaller factors, k1, k2, k3, m do not have patterns. But it is possible that products of some of these factors may have patterns.

puts k*k1*k2*k3*m*n # gives 657 ones, so the factors are faithfully copied over from Mr. Kamada

#Now, look at interesting numbers, R657 divided by various factors

puts k*k1*k2*k3*m #it is palindromic, see below

#puts j657/k

puts j657/k1 # has long repeated sections, 9 sections. Three and nine are numbers that are commonly seen with repunits.

puts j657/k2 # has 3 long repeats

puts j657/k3 # has long repeated sections, again 9 sections.

puts j657/m # has 3 long repeats

end of Ruby code

Here is the output area copied out of Ruby

999000000999000000999000000999000000999000000999000000999000000999000000999000000999000000999000000999000000999000000999000000999000000999000000999000000

999000000999000000999000000999000000999000000999000000999000000999999000999999000999999000999999000999999000999999000999999000999999000999999000999999000

999999000999999000999999000999999000999999000999999000999999000999999000999999000999999000999999000999999000999999000999999001

above supposed to be 432 digits and may not be prime, prime-finding algorithms choke at around 200 digits, so this 432-digit number, a probable prime, may never be finally determined to be a real prime number

111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111

111111111111111111111111111111111111111111111

111222333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333

333333333333333333333333333333333333333333333333333333333333333333222111

59891914573337864083467791233401562326986319494768428300000000000000000005989191457333786408346779123340156232698631949476842830000000000000000000

598919145733378640834677912334015623269863194947684283

2826081819388095225039404226165553589913372431414845108669609509592632224357654741394523810829392910716777974341996090191848822466372382374070110869307041

00000000000000000000000000000000000000000000000000000000000000000

2826081819388095225039404226165553589913372431414845108669609509592632224357654741394523810829392910716777974341996090191848822466372382374070110869307041

00000000000000000000000000000000000000000000000000000000000000000

2826081819388095225039404226165553589913372431414845108669609509592632224357654741394523810829392910716777974341996090191848822466372382374070110869307041

225801897481247081810610976030000000000000000000000000000000000000000000022580189748124708181061097603

00000000000000000000000000000000000000000000

225801897481247081810610976030000000000000000000000000000000000000000000022580189748124708181061097603

00000000000000000000000000000000000000000000

225801897481247081810610976030000000000000000000000000000000000000000000022580189748124708181061097603

00000000000000000000000000000000000000000000

225801897481247081810610976030000000000000000000000000000000000000000000022580189748124708181061097603

00000000000000000000000000000000000000000000

22580189748124708181061097603

4709345395908458467993332554790697947714133277912605329176022426596895292828528793742487486534000077854263538561920005542072800415731090673643804003387

00000000000000000000000000000000000000000000000000000000000000000000

4709345395908458467993332554790697947714133277912605329176022426596895292828528793742487486534000077854263538561920005542072800415731090673643804003387

00000000000000000000000000000000000000000000000000000000000000000000

4709345395908458467993332554790697947714133277912605329176022426596895292828528793742487486534000077854263538561920005542072800415731090673643804003387

Through the help of Ruby, we find curious numbers (non-prime, in other words composite) that are factors of R657. Something about the repeating nature of these factors suits them to compose repunits. The long strings of zeros are remarkable. A conclusion: patterns within factors are abundant for repunits.

A strange thing is that these long factors are repeated groups, repeating either 3 or 6 times. But the n number, the 432-digit factor starting 999000000... , sort of has a repetition of 2.

Document A, continued

R322

The 322-digit repunit is seen in https://stdkmd.net/nrr/repunit/tm.cgi?p=4. It has as one of its prime factors 11111111111111111111111, the 23rd repunit. There are 19 other prime factors of R322. It must be that R322/R23 is a number similar to 10000001000000100000010000001. Ruby makes the division and shows that this is true. In fact 322/23 = 14. There are 14 ones in R322/R23, so that R23 gets laid in there 14 times.

I have found that it is commonplace for various factors of repunits to multiply up to numbers like 10000001000000100000010000001, and the other factors to multiply up to composite repunits. This is part of the reason that repunits are rarely prime numbers; if you can get smaller factors to multiply up to a number like 10000001000000100000010000001, it only takes a shorter repunit to multiply by, and you have your long repunit.

By previous observations, R23 (11111111111111111111111) must be a factor of periodic repunits, and by doing "find in this page" on the stdkmd.net web site, I find the period to be the very short period 23. R46, R69...R322, R345, R368, R391 all need R23 as a factor.

Similarly, if we consider the next prime repunit below R23, which is R19, R19 is a factor of every 19th repunit.

factordb.com is an alternative to Ruby, shown following.

Whereas Ruby can do arbitrary-precision math to find the full numbers in stdkmd.net - repunits, the ones that Mr. Kamada abbreviates, there is an alternative to Ruby. It is factordb.com.

Put in your number--I put in the 313th repunit, taking advantage of the algebra representation.

This problem is shown, by the way, in my Time Line at 1966. You are on this web page https://sites.google.com/site/solderandcircuits/home/more-circuit-design/physics-timeline/physics-time-line-1900-1990/repunits-decimal-numbers-that-are-all-onesA

Well, factordb.com shows the 294-digit factor in abbreviated form. But you may click on it and you see the full number!

Who knows how big a factor is usable this way?

Document B

This is the story of how I stumbled into repunits. I didn't know the name, repunit, for two years.

Document C

Repunits, the All-Ones Numbers

In 1966, Albert Beiler wrote a book, Recreations in the Theory of Numbers. He coined the word repunit for all-ones numbers. Repunit means repeating unit. Repunits have interesting properties. One property is that almost all repunits are not prime numbers; almost all repunits are composite numbers, multiplied up from smaller, prime numbers.

The exceptions are 11, 1111111111111111111, and 11111111111111111111111. (2 ones, 19 ones, and 23 ones. Also, 317 and 1031 ones.) Primes.utm.edu/glossary/xpage/Repunit.html. These few repunits are prime numbers.

An over-the-top web site is Mr. Makoto Kamada's mysterious stdkmd.net/nrr/repunit, where he presents the factors of all repunits, up to 300,000 ones! But past 600 ones, many factors are too long to be proven prime. They are probable primes. Mr. Kamada's web page has a bibliography. Also see factordb.com, an interactive, on-line database.

We can look at the factorization of the ninth repunit and find the prime factors are 3, 3, 37, 333667. (Check it out, 3 x 3 x 37 x 333667 = 111111111.)

If you double the ones from nine to eighteen and factor the eighteenth repunit, all of the factors of the ninth repunit are needed, plus new factors 11, 7, 13, 19, and 52579. If we double again to 36 ones, we need all of eighteen's factors, plus new factors, 101, 9901, and 999999000001.

The notable prime factor 333667 is a factor of the ninth repunit, and the eighteenth, and the 27th, and the 36th as noted above, and the 45th, and every repunit that is a multiple of nine.

Other prime factors are notable. 9901 and 999999000001 are mentioned above. 909090909090909091 shows up at the 38th repunit, and 76, and every multiple of 38. Just browse stdkmd.net/nrr/repunit and you see these strange numbers. At 78, we find 900900900900990990990991. At the midpoint, it changes from 900 to 990.

In general, we find that repunit factoring of larger and larger repunits keeps drawing on the same pool of factors. These factors, when multiplied to produce (non-prime) factors, tend to create strange numbers like 10000001000000100000010000001. Such a strange number, when multiplied by the seventh repunit 1111111, produces the 35th repunit.

If you take half an hour to put pencil to paper and manually multiply the factors of any repunit, it is amazing to see the all-ones product take shape.

Look at stdkmd.net/nrr/repunit and see how often 41 and 271 are factors of repunits. They are needed together at 5, 10, 15, 20, etc. Now look for 9091. It is needed at 10, 20, 30, etc.

Now look for the factors 7 and 13. They are needed at 6, 12, 18, etc. How about 239 and 4649? They are needed at 7, 14, 21, 28, etc. And 43 is needed at every third of those, starting at 21.

The trend is that various factors are periodic, with different periods. Here are the periods that show up: 2, 3, 5-10, 13, 15, 16, 18, etc. It is a truth that the prime repunits at 19, 23, 317, and 1031 occur where these periods “stumble,” where no period gives coverage. This is why there are so few prime repunits; the periodic factors give almost complete coverage. This is similar to the Sieve of Eratosthenes with prime numbers.

If you can apply more thinking that I am able, you can see why some sage notes that 19, 23, 317, and 1031 are all prime numbers.

Python, the coding language, handles integers of any length (up to the limit of memory) and may be used to multiply and divide these large factors and repunits. A handy and free IDE for Python is Thonny. But Ruby can do these giant multiplies and divides, plus has underscores to use as markers.

The Python module, itertools, has a permutation method that can produce every permutation of a list of integers. The permutations can be used on the factors of any repunit to find the above-noted strange numbers, using a Python program that looks for runs of zeros. This is Document E, below.

Wikipedia has a repunit entry. It gets very complicated.

All in all, the repunits are interesting numbers. They are part of the ubiquity of math.

Physics is Math

I mention four instances of math amazement.

DNA's rungs are organized in groups of three nucleotide bases, where the bases are abbreviated A, C, G, and T. All permutations of these four make up the twenty amino acids of all life, plant and animal. DNA is thereby a language with four letters, and DNA is a digital code for protein manufacture. In addition to the groups of three, there are start and stop sequences for proteins. The language nature of DNA is presented in many Internet sites, such as ucg.org/the-good-news/dna-the-tiny-code-thats-toppling-evolution. This web site says that the digital nature of DNA allows DNA to replicate with an error rate of 1 in 10 billion, each error causing a mutation. So little is the wiggle room for error, and so overarching are the harmful mutations compared to beneficial mutations, that evolutionists, when they are frank, admit that the materialist origin of self-replicating DNA, plus the complex molecular machinery to do the replicating, is a complete puzzle. Materialist evolutionists keep hoping for some breakthrough that will show how self-replicating life started. They learn amazing things about genetics and molecular biology, but they are far away from showing how the complicated machinery of life started from random assemblages of molecules.
In 1960, physicist Eugene Wigner said, in science-sounding language, “The miracle of the appropriateness of the language of mathematics to the formulation of the laws of physics is a wonderful gift which we neither understand nor deserve.”

3. In 2014, Max Tegmark says, “Many of my physics colleagues will say that mathematics describes our physical reality, at least in some approximate sense. I go further and argue that it actually is our physical reality, because I'm arguing that our physical world doesn't just have some mathematical properties, but it has only mathematical properties.” On April 15, 2015, Max Tegmark is on PBS' Nova, 'The Great Math Mystery.' Is math invented by humans, or is it the language of the universe?

4. 2013: Is Mathematics Invented or Discovered?
Fonts in the original Apache OpenOffice 4.1.2 document: Arial, Segoe Print, Fang Song

Document D

The periodic nature of the factors of repunits can be appreciated graphically. Every colored cell below is a factor of a repunit.

Repunit Periodic Factors JE

Document E Permutations of the Factors of Repunits

correlate_for_repunit_factorsVer3.py

from itertools import permutations # from Geeks for Geeks web site

import time , math

perm_list = list(permutations( [ 11,101,41,271,9091,3541,27961 ] ) ) #for 20th repunit

# reference # of permutations for 7 items is 5040

itCount=0

for i89 in perm_list:

itCount += 1

if itCount%300==0:

print(itCount)

print('kk ',i89) #the permutation of the factors to be considered, multiply left to right

int93 = 1

for i91 in i89:

int93 *= i91 #start multiplying the factors after making the sliding versions with qs

#throaway=input('xxxx')

e= str(int93)

lene=len(e)

f='q'*lene+e+'q'*lene

#print (len(f),f,len(e))

glist= [] # build up correlation factors

for j in range(0,2*(lene)+1 ): #slide f under e to check correlations

h = f[j:j+lene]

#print(h,j)

#throwaway=input('xxxx')

numSame=0; el=list(e); hl=list(h); multCount=0; interesting=False

for i in range(0,lene):

multCount += 1

if el[i]==hl[i]:

numSame+=1 # number of digits the same between ref and the sliding version

glist.append(numSame)

if( (3<multCount<(lene/3) and numSame>3) or ((lene/3)<=multCount<(2*lene/3) and numSame>4)\

or ((2*lene/3)<=multCount<lene) and numSame>(lene-2) ): # this isn’t working

print('mmm ',e,' ',' mmm ',glist[0:int(len(glist)/2+1)])

if int(e)>10000000:

print(glist[0:int(len(glist)/2+1)], e)

throaway=input('xxxx')

Patterns of Digits When Prime Factors Multiply Up to Repunits

For the particular order (given below, starting “kk”) of multiplications of the seven factors for the twentieth repunit, 11111111111111111111, the first multiply (27961*3541) = 99009901, a product that has a definite pattern. Then the Python shell shows the rest of the multiplies as we build up to the sixth multiply. It is often the case, in fact true in more than half the permutations, that patterns of numbers crop up during the six multiplies.

The seven factors are on the next line.

kk (27961, 3541, 271, 9091, 101, 41, 11)

[0, 0, 0, 1, 3, 2, 0, 3, 8] 99009901

The square-bracket numbers before the next product show an autocorrelation that shows four digits, 6831, that show up twice.

[0, 0, 0, 0, 0, 1, 0, 4, 0, 1, 0, 11] 26831683171

[0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 15] 243926831707561

The next autocorrelation shows a strong repeat, 2463661.

[0, 0, 0, 0, 1, 1, 1, 7, 1, 1, 1, 0, 0, 0, 2, 3, 4, 17] 24636610002463661

The next one is 11111111111111111111/11 which can be expected to have a strong repeat, based on the autocorrelation numbers 7, 9, 11, etc.

[0, 1, 0, 3, 0, 5, 0, 7, 0, 9, 0, 11, 0, 13, 0, 15, 0, 17, 0, 19] 1010101010101010101

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20] 11111111111111111111

This has been one example. There are another 5039 possible permutations. Let's look at 8 more examples.

Other permutations of the factors give other strong patterns of numbers. (The final one or two multiplies to get the repunit are omitted for brevity.)

kk (11, 101, 41, 271, 3541, 27961, 9091)

[0, 1, 0, 1, 0, 1, 0, 1, 8] 12344321

[0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 2, 11] 43711240661

[0, 1, 0, 1, 2, 3, 6, 3, 2, 1, 0, 3, 0, 3, 6, 9, 16] 1222210000122221

kk (11, 101, 41, 9091, 3541, 27961, 271)

[0, 0, 2, 0, 4, 0, 2, 4, 0, 9] 414104141

[0, 1, 0, 0, 0, 0, 0, 1, 2, 2, 0, 0, 1, 13] 1466342763281

[0, 0, 2, 0, 0, 1, 2, 7, 2, 1, 2, 4, 12, 4, 2, 3, 6, 17] 41000410004100041

kk (11, 101, 271, 9091, 3541, 27961, 41)

[0, 0, 0, 1, 0, 5, 0, 1, 2, 0, 10] 2737127371

[0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 2, 1, 13] 9692168020711

[0, 0, 0, 3, 0, 0, 0, 1, 8, 1, 0, 0, 2, 13, 2, 0, 0, 3, 18] 271002710027100271

kk (11, 101, 3541, 27961, 9091, 41, 271)

[0, 1, 2, 1, 0, 1, 2, 3, 4, 5, 6, 9, 12] 110000000011

[0, 1, 0, 1, 2, 3, 6, 3, 4, 5, 6, 11, 6, 7, 8, 9, 16] 1000010000100001

kk (11, 41, 9091, 271, 27961, 3541, 101)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 1111111111

[0, 0, 1, 0, 0, 0, 2, 1, 1, 2, 3, 4, 4, 5, 14] 31067777774671

[0, 1, 2, 1, 0, 3, 6, 3, 0, 5, 10, 5, 0, 7, 14, 7, 0, 9, 18] 110011001100110011

kk (11, 271, 3541, 27961, 101, 9091, 41)

[0, 1, 0, 0, 0, 0, 1, 2, 8] 10555721

[0, 0, 0, 0, 1, 0, 0, 1, 5, 0, 0, 1, 12] 295148514881

[0, 0, 0, 0, 4, 0, 0, 0, 0, 1, 2, 3, 4, 5, 14] 29810000002981

kk (11, 271, 27961, 3541, 9091, 41, 101)

[0, 0, 0, 0, 0, 1, 0, 1, 8] 83351741

[0, 0, 0, 0, 1, 0, 0, 1, 5, 0, 0, 1, 12] 295148514881

[0, 0, 0, 0, 0, 1, 0, 3, 1, 1, 1, 0, 1, 1, 2, 0, 16] 2683195148783171

[0, 1, 2, 1, 0, 3, 6, 3, 0, 5, 10, 5, 0, 7, 14, 7, 0, 9, 18] 110011001100110011

kk (9091, 27961, 101, 3541, 11, 41, 271)

[0, 0, 0, 1, 1, 1, 0, 0, 0, 9] 254193451

[0, 0, 0, 1, 1, 0, 0, 2, 1, 1, 1, 11] 25673538551

[0, 0, 1, 0, 4, 0, 2, 2, 2, 3, 4, 5, 7, 5, 14] 90910000009091

[0, 1, 0, 1, 2, 3, 6, 3, 4, 5, 6, 11, 6, 7, 8, 9, 16] 1000010000100001

These nine permutations are a selection from the total of 5040 permutations of the seven prime factors of the twentieth repunit. This shows the general behavior when the product is a repunit. The patterns are a result of the special set of prime numbers that are peculiarly suited to producing repunits. This set is 11, 101, 3, 37, 41, 271, 9091, 7, 13, 239, 4649, 43, 29, 73, 137, 17, 333667, 19, 53, 79, 859, 31, 2906161. (And others, for repunits past 11 digits.)

When other factors are chosen to intentionally not produce a repunit, like 3*13*71*53*307 = 39*3763*307 = 146757*307 = 45054399, it is unusual to get patterns in the sub-products. So we are seeing an unusual property for repunits.

Sometimes Few Factors, Sometimes Many

There is a curious split between even-digited repunits and odd-digited repunits.

For some repunits, always repunits that have an odd number of digits, there are few prime factors. An example is for 13 digits, which has factors of 53, 79, and 265371653. The 17th repunit has only two factors. The 19th, 23rd, and 317th repunits are prime numbers and have no sub-factors at all. The web site of Makoto Kamada, stdkmd.net/nrr/repunit, has the factorizations of the first 300,000 repunits! It readily shows all factors of all these repunits, though many of the factors, the ones above 200 digits, are only suspected to be primes and may never be proven to be prime numbers.

The repunits with few factors can be viewed as almost being prime repunits. The few factors that they have can be thought of as rogue factors that just happened to come to the rescue, saving the repunit from being a prime number.

On the other hand, even-digited repunits have many factors, and those factors have special combinations that work together to produce repunits. (See above, 11, 101, 3, 37, 41, 271, 9091, 7, 13, etc.)

Here are examples of the “working together.” 11*101=1111, which works with 73*137=10001 to produce 1111*10001=11111111. 1111 and 10001 work with 17 and 5882353 (these last two multiply to 100000001) to make the 16th repunit. There is no end of this “working together” for even-digited repunits, and many odd-digited, too. The 60th repunit has 20 factors, the largest of which is just eight digits. But its neighbor, the 59th, is almost a prime number, for it has just two factors, a 13-digit prime and a 46-digit prime!

The 317th-digit repunit, a prime, has a neighbor at 313 which has just three factors, with digit counts of 4, 16, and 294. It might seem extraordinary that a 294-digit prime factor would come to the rescue of the 313th repunit, saving it from being a prime repunit. But we must bear in mind that there are billions and quadrillions and quintillions of numbers in the area of the 294-digit factor that could have been “tried,” so maybe we shouldn’t be surprised that there is a particular, 294-digit number that rescues the 317th.

The Sieve-of-Eratosthenes View of Prime Repunits

Another way to think about the scarcity of repunit primes is that the common factors of repunits, shown above, 11, 101, 3, 37, 41, 271, 9091, 7, 13, etc., each has a period of repetition for the various repunits. 11 and 101 are factors of every other repunit. 3 and 37 are factors of every third repunit. 9091 is a factor of every tenth repunit. There is no end of these periodic factors, and in fact, if there is a factor of an x-digit repunit, it will be a factor of the 2x, 3x, 4x, etc. repunits. (9091 is a factor for the 10th, 20th, 30th, etc.) I do not know of a proof of this, I am just saying that I observe the property. If all of these periodic factors fail to “cover” for a particular repunit, then you have one of the rare prime repunits.

Just as with the Sieve of Eratosthenes, the repunit-factor sieve, if we can call it that, insures there are fewer and fewer prime repunits as you add digits. One source on Internet says that each repunit introduces a new factor, and those factors always repeat.

Value of Internet to Repunit Thinking

The formula for repunits is (10n-1)/9. Stdkmd.net/nrr/repunit has been mentioned. Another web site that is useful is the factors database, factordb.com. Another site is OEIS, the on-line encyclopedia of integer sequences. Wikipedia’s Repunit gets deep into math. While looking through stdkmd.net/nrr/repunit, I find that integers with length around 200 digits are where computer factorizations are currently working to prove that probable prime (PP) numbers are actually primes.

My personal discovery, about 2017, that the factors of repunits repeat or are periodic is a fact that certainly has been around for decades, but it seems to be disguised in the intense math that is seen in Internet and in journal papers. I have thought for several years about why the factors are periodic, and the reason seems to be the proclivity of certain factors to make smaller repunits (11*101=1111) and the proclivity of other factors to make cooperating numbers like 10001=73*137, giving 1111*10001 = 11111111. In my earlier spreadsheet work on repunits, I call these numbers building blocks.

The periodic nature of repunit factors is colorfully presented at my site,

sites.google.com/site/solderandcircuits/home/more-circuit-design/physics-timeline/physics-time-line-1900-1990/repunits-decimal-numbers-that-are-all-ones. Look for the Google sheet linked to on that page.

Document F Addition to Document E

All-Ones Integers (Repunits) are Rarely Prime Numbers

File 20th repunit notable patterns during multiplies of factors.odt on computer LAPTOP LENOVO

Abstract

All-ones numbers (the “repunits”) like 11111 and 11111111111111 are almost always composite numbers, not prime numbers. There are some reasons for this, but you have to tease them out.

Repunits are such significant numbers that recreational mathematicians have spent a lot of work on them. A long Wikipedia page is about them. Web sites are devoted to them. And much of this attention is because they are rarely prime numbers.

One important feature of repunit factors, the periodic nature of prime factors of repunits, is not an emphasis in this essay. I have other documents (Doc D on this web page) that talk about the periodicity. But here is the idea. 11 and 101 are factors of every repunit that has an even number of digits, starting with 1111. 41 and 271 are factors of every repunit that has five digits or a multiple of 5. 333667 is a factor of every repunit that has a multiple of 9 digits. 265371653 is a factor of every 13th repunit. There is no end to this trend.

Table of Contents of Doc F

Number Patterns During Multiplication of Factors of R20

The Python Code

Number Patterns During Multiplication of Factors of R33

Number Patterns During Multiplication of Factors of R74

Number Patterns During Multiplication of Factors of R40

Are These Digit Patterns Significant?

Two Checks on the Multiplication Process

Where is the Pattern and What is the Significance?

Repunits with Few Prime Factors

The Few Prime Repunits

Conclusions

Appendix

The Python code is correlate_for_repunit_factorsVer5.py

John Engelbrecht Nov 19 2021

See page 4 of this LibreOffice Writer document for rationale.

The tail end of the iterating, in the Shell of Thonny, for...

Repunit 20, the number 11111111111111111111

Eleven permutations of the prime factors of the 20th repunit are shown here. Notice how 101 hops around, each of the eleven is a different order of factors.

starting iteration # (27961, 3541, 9091, 41, 11, 271, 101)

mmm 405944653505941 mmm [0, 0, 1, 0, 0, 0, 4, 1, 1, 0, 2, 2, 0, 2, 1] multCount= 5 sumgl/lene= 0.9

{'357676767641', '1111111111', '29810000002981', '114641246401', '24636610002463661', '110000000011', '410000000041', '112222222211', '31067777774671', '3934444444051', '10202020201', '90910000009091', '1000010000100001', '757750677431', '4510000000451', '414104141', '10001000100010001', '31378141771', '1100099010011', '2710000000271', '9901089109901', '405944653505941', '3727310000372731', '12101089110121', '111110000011111'}

starting iteration # (27961, 3541, 9091, 41, 101, 11, 271)

mmm 3727310000372731 mmm [0, 0, 1, 0, 1, 0, 6, 0, 1, 0, 1, 0, 2, 1, 4, 3] multCount= 5 sumgl/lene= 1.2

{'357676767641', '1111111111', '29810000002981', '114641246401', '24636610002463661', '110000000011', '410000000041', '112222222211', '31067777774671', '3934444444051', '10202020201', '90910000009091', '1000010000100001', '757750677431', '4510000000451', '414104141', '10001000100010001', '31378141771', '1100099010011', '2710000000271', '9901089109901', '405944653505941', '3727310000372731', '12101089110121', '111110000011111'}

starting iteration # (27961, 3541, 9091, 41, 101, 271, 11)

mmm 3727310000372731 mmm [0, 0, 1, 0, 1, 0, 6, 0, 1, 0, 1, 0, 2, 1, 4, 3] multCount= 5 sumgl/lene= 1.2

{'357676767641', '1111111111', '29810000002981', '114641246401', '24636610002463661', '110000000011', '410000000041', '112222222211', '31067777774671', '3934444444051', '10202020201', '90910000009091', '1000010000100001', '757750677431', '4510000000451', '414104141', '10001000100010001', '31378141771', '1100099010011', '2710000000271', '9901089109901', '405944653505941', '3727310000372731', '12101089110121', '111110000011111'}

starting iteration # (27961, 3541, 9091, 41, 271, 11, 101)

mmm 10001000100010001 mmm [0, 1, 0, 1, 2, 5, 2, 3, 4, 9, 4, 5, 6, 13, 6, 7, 8] multCount= 5 sumgl/lene= 4.5

{'357676767641', '1111111111', '29810000002981', '114641246401', '24636610002463661', '110000000011', '410000000041', '112222222211', '31067777774671', '3934444444051', '10202020201', '90910000009091', '1000010000100001', '757750677431', '4510000000451', '414104141', '10001000100010001', '31378141771', '1100099010011', '2710000000271', '9901089109901', '405944653505941', '3727310000372731', '12101089110121', '111110000011111'}

starting iteration # (27961, 3541, 9091, 41, 271, 101, 11)

mmm 10001000100010001 mmm [0, 1, 0, 1, 2, 5, 2, 3, 4, 9, 4, 5, 6, 13, 6, 7, 8] multCount= 5 sumgl/lene= 4.5

{'357676767641', '1111111111', '29810000002981', '114641246401', '24636610002463661', '110000000011', '410000000041', '112222222211', '31067777774671', '3934444444051', '10202020201', '90910000009091', '1000010000100001', '757750677431', '4510000000451', '414104141', '10001000100010001', '31378141771', '1100099010011', '2710000000271', '9901089109901', '405944653505941', '3727310000372731', '12101089110121', '111110000011111'}

starting iteration # (27961, 3541, 9091, 271, 11, 101, 41)

starting iteration # (27961, 3541, 9091, 271, 11, 41, 101)

starting iteration # (27961, 3541, 9091, 271, 101, 11, 41)

mmm 24636610002463661 mmm [0, 0, 0, 0, 1, 1, 1, 7, 1, 1, 1, 0, 0, 0, 2, 3, 4] multCount= 5 sumgl/lene= 1.3

{'357676767641', '1111111111', '29810000002981', '114641246401', '24636610002463661', '110000000011', '410000000041', '112222222211', '31067777774671', '3934444444051', '10202020201', '90910000009091', '1000010000100001', '757750677431', '4510000000451', '414104141', '10001000100010001', '31378141771', '1100099010011', '2710000000271', '9901089109901', '405944653505941', '3727310000372731', '12101089110121', '111110000011111'}

starting iteration # (27961, 3541, 9091, 271, 101, 41, 11)

mmm 24636610002463661 mmm [0, 0, 0, 0, 1, 1, 1, 7, 1, 1, 1, 0, 0, 0, 2, 3, 4] multCount= 5 sumgl/lene= 1.3

{'357676767641', '1111111111', '29810000002981', '114641246401', '24636610002463661', '110000000011', '410000000041', '112222222211', 101'31067777774671', '3934444444051', '10202020201', '90910000009091', '1000010000100001', '757750677431', '4510000000451', '414104141', '10001000100010001', '31378141771', '1100099010011', '2710000000271', '9901089109901', '405944653505941', '3727310000372731', '12101089110121', '111110000011111'}

starting iteration # (27961, 3541, 9091, 271, 41, 11, 101)

mmm 10001000100010001 mmm [0, 1, 0, 1, 2, 5, 2, 3, 4, 9, 4, 5, 6, 13, 6, 7, 8] multCount= 5 sumgl/lene= 4.5

{'357676767641', '1111111111', '29810000002981', '114641246401', '24636610002463661', '110000000011', '410000000041', '112222222211', '31067777774671', '3934444444051', '10202020201', '90910000009091', '1000010000100001', '757750677431', '4510000000451', '414104141', '10001000100010001', '31378141771', '1100099010011', '2710000000271', '9901089109901', '405944653505941', '3727310000372731', '12101089110121', '111110000011111'}

starting iteration # (27961, 3541, 9091, 271, 41, 101, 11)

mmm 10001000100010001 mmm [0, 1, 0, 1, 2, 5, 2, 3, 4, 9, 4, 5, 6, 13, 6, 7, 8] multCount= 5 sumgl/lene= 4.5

set of patterns for Repunit 20 after searching all 5040 permutations

{'357676767641', '1111111111', '29810000002981', '114641246401', '24636610002463661', '110000000011', '410000000041', '112222222211', '31067777774671', '3934444444051', '10202020201', '90910000009091', '1000010000100001', '757750677431', '4510000000451', '414104141', '10001000100010001', '31378141771', '1100099010011', '2710000000271', '9901089109901', '405944653505941', '3727310000372731', '12101089110121', '111110000011111'}

It takes 5 minutes when time.sleep(.061)

Not all of these would show up on any single permutation of the factors of Repunit 20. But notice the patterns in these numbers; they are not random.

Document F, continued

# file correlate_for_repunit_factorsVer5.py JE 11-15-21

# Python code to take the prime factors of a repunit like 11111111111111111111,

# where the prime factors can be from stdkmd.net/nrr/repunit (thanks to Mr. Makoto Kamada),

# find all permutations of the factors, multiply the factors for each permutation,

# and look for interesting patterns of digits. Patterns are present for repunits but not

# so much for non-repunits.

# Ver4 made a little headway but length of e needs to be better

# numSame=0; el=list(e); hl=list(h); multCount; lene seems to be messed up, and selection of numSame up to the

# middle needs smoothing out. numSame,multCount,lene were all incrementing at the same time, not good.

from itertools import permutations # from Geeks for Geeks web site

import time , math

perm_list = list(permutations( [ 11,101,41,271,9091,3541,27961 ] ) ) #for 20th repunit

# reference # of permutations for 7 items is 5040

itCount=0

no_dups = set({})

for i89 in perm_list:

itCount += 1 #iteration count, there are 5040 iterations of 7 items

if itCount%300==0:

print('===========itCount every 300',itCount)

print('starting iteration #',i89) #the permutation of the factors to be considered,

multiply left to right

int93 = 1; multCount=0

for i91 in i89:

int93 *= i91 #start multiplying the factors after making the sliding versions with qs

multCount += 1

e= str(int93) #e will increase in length as the for loop advances

lene=len(e)

f='q'*lene+e+'q'*lene #f is buffered on front and back with a non-digit char

glist= [] # build up correlation factors

for j in range(0,2*(lene)+1 ): #slide f under e to check correlations

h = f[j:j+lene] # h is a slice of the string f, len(h)=len(e)

numSame=0; el=list(e); hl=list(h)

for i in range(0,len(el)):

if el[i]==hl[i]:

numSame+=1 # number of digits the same between ref and the sliding

version

glist.append(numSame) # glist now has the number of digit matches for the whole

slide and it seems

# always to be symmetric. Always has an odd number of items.

glistShort = glist[0:(int((len(glist)-1)/2))] #exclude the perfect-match at the

middle

sumgl = 0

for sg in glistShort:

sumgl += sg

ignoret = ( multCount >= (len(i89)-1) )

if( ((sumgl/lene) > .9) and (not ignoret) and multCount>3 ): # there is a fair

amount of autocorrelation

print('mmm ',e,' ',' mmm ',glistShort, ' multCount=',multCount,'

sumgl/lene=',round(sumgl/lene,1) )

no_dups.add(e)

print(no_dups)

time.sleep(.061)

#if( ((sumgl/lene) > .9)… the .9 needs to be tuned to get a reasonable number of

#interesting patterns. 0.9 is fine for R20, 4.5 for R74

Patterns for R33

The code turns up interesting patterns for some permutations of the factors. It is a fact that the various patterns turn up a lot, as duplicates. The Python set, no_dups, conveniently tallies only non-duplicated patterns.

starting iteration # (1344628210313298373, 513239, 21649, 67, 37, 3)

mmm 1001001001001001001001001001001 mmm [0, 1, 0, 1, 4, 1, 2, 7, 2, 3, 10, 3, 4, 13, 4, 5, 16, 5, 6, 19, 6, 7, 22, 7, 8, 25, 8, 9, 28, 9, 10] multCount= 4 sumgl/lene= 7.9

{'10000000000100000000001', '2233333333311',

'1710796666683774633333504413', '27544444444169',

'72163333334054966666673883', '1001001001001001001001001001001',

'1233333333321'}

For R74

{'10000000000000000000000000000000000001', '3406089983106652898888888888888888888548279890578223599', '12222222222222222222222222222222222221', '2389922711182695562941111111111111110872118839992841554817', '22123942967702033680130000000000000002212394296770203368013', '1843744545454545454545454545454545454729829', '225117284545454545454545454545454545477057183', '5165723123421092222222222222222222221705649909880113', '469611193038281111111111111111111111064149991807283', '20281190000000000000000000000000000002028119', '3624589800497676987777777777777777777415318797728010079', '8058888888888888888888888888888888888083', '2476290130000000000000000000000000000247629013', '88647777777777777777777777777777777768913', '329508163681606998888888888888888888855938072520728189'}

The patterns are much the same for different repunits.

Document F, continued

By copy-pasting into LibreOffice Writer, and "find all," then color coding, we see the patterns pop out.

Document F, continued

For R40,

There are 11 factors which demand 11! = 39,916,800 permutations, which overloads memory. But I see common prime factors that always get paired during multiplication, so try pre-multiplying to get the number of factors from 11 down to 6, which is readily handled by the Python program. Here is the pairing: [11*101,41*271*9091,73*137, 3541*27961,

starting iteration # (5964848081, 1676321, 99009901, 10001, 101010101, 1111)

mmm 9900990100000000000099009901 mmm [0, 0, 0, 1, 3, 2, 0, 3, 8, 3, 1, 4, 6, 5, 5, 6, 6, 7, 8, 9, 10, 11, 11, 13, 17, 15, 11, 17] multCount= 4 sumgl/lene= 6.5

b = 1010202020101 remarkable for having 0 at every other digit, otherwise only 0, 1, 2

c = 1099890011108889111099890011 remarkable for only 0, 1, 8, 9

2c = 2199780022217778222199780022

The numbers are associated with an adjunct little Python program.

A=(10**40-1)//9 #the formula for an all-ones number of 40 digits

print(a,len(str(a)) )

c=1099890011108889111099890011

print(a//c)

b=1010202020101

print( c*2)

Shell--------------

1111111111111111111111111111111111111111 40

1010202020101

2199780022217778222199780022

Two Checks on the Multiplication Process Before We Go On

1) Let’s do a junior version to cement the technique.

271

x 41

271 Carries 01100

1084.

11111

Where is the Pattern and What is the Significance?

Let’s return to the 40th repunit, b*c multiply from above, the one with the striking 7-8-9 waterfall. Having carried out the addition and witnessed the forty ones develop, I can’t say there is an ah-ha moment where the patterns in c are seen to be critical to getting all ones.

But we can look at the c number 1099890011108889111099890011. It has a “wave” of 8-9 crests and 0-1 troughs. This crest-and-trough pattern cooperates with the shifting due to multiplication by b, which produces the cascades or waterfall of 7-9 shown in yellow. The cascades smear out the 7-9 entries so that each column has from two to four sevens, eights, and nines, giving rise to the narrow range of carries of 2, 3, and 4. Likewise in the 271*41 example, there is a cascade of 7-8.

The critical point is that the additions of columns always give 1, 11, 21, 31, or 41. You write down the one and do the carry to the next column, and it achieves a product of all ones.

Here is a further insight about crest-and-trough pattern in the c number, 1099890011108889111099890011. This pattern might also be in 9900990100000000000099009901 and 596604116992509250919126468081. The charts below are for moving averages of the digits in these three numbers, respectively.

It may be important that 1) between the b and c numbers, there are no digits from 3 to 7, and 2) the b number has no digit over 2.

Repunits with Few Prime Factors

If these facts evoke marvel (they do for me), there is also marvel about odd-digited repunits with few prime factors, such as

R25 and R29 with only five prime factors,
R31, R37, and R67 with only three prime factors,
R47 and R59 with only two prime factors.
(Credit to stdkmd.net/nrr/repunit, by Makoto Kamada)

These large, odd-digited, few-prime-factors repunits probably do not benefit from any sort of digit patterns that are explored above, because the preceding development is for repunits with many factors. The few-factored repunits can be viewed as extreme coincidences of multiplication, yielding all-ones products from so few (two to five) prime factors.

As we think about repunits with 5, 3, or 2 factors, we should think about how the prime-number repunits (no factors) R317 and R1031 are examples of odd-digited repunits where “no factors come to the rescue” to save them from being prime numbers. We do so in the next paragraph. (It is remarkable that so many repunits are rescued from being primes, by fortuitous multiplications.) In fact, we can think about the rarity of repunit primes in three ways.

Rarity of General Primes

Bear in mind that repunits are prime numbers at a vanishingly reduced rate compared to general numbers.

But even general numbers around 10^1031 are rarely prime. The prime gap function for 10^1031, which gives the average number of non-prime numbers between prime integers, near the R1031 repunit that we are talking about (about 10^1031), shows that the average gap between primes is 2373. Yes, for these very large numbers, the Sieve of Eratosthenes causes almost all numbers to be composite. (This is why recreational mathematicians put so much work into finding prime numbers, there aren’t very many when the number of digits is 1031. Gaps of 2373 are merely the average, it is known that there are some gaps in the millions!)

Rarity of Repunit Primes

The number of prime repunits up to and including R1031 is only five, out of 1031 repunits up to 1031 digits, which averages to 1 in 206 repunits. Indeed, there aren’t many prime repunits.

In terms of the average number of integers between prime repunits, in the area of the 1031st repunit, it is roughly one repunit per .2*10^1031 integers. That is vanishingly small.

Quantity of Factors Relates to Rarity of Prime Repunits

Think about the area around the prime repunit R1031. A neighbor, R1033, has only six suspected factors, while many other repunits in this area have thirty suspected factors, the “suspected” being from the inability to prove that giant integers are primes. I have a feeling that large repunits (1031±100 digits) are “further away from being prime” when they have large numbers of factors. This is more than a feeling, though, because the sieve nature of the prime factors of repunits (the periodic nature of repunit factors) amounts to insurance that very few large repunits survive the sieve.

Document F, continued

Conclusions

In the fewest words, repunits have unique properties of rarely being prime numbers. The factors of repunits are from a pool of numbers (see Abstact)(repunit sieving) that have special properties. Repunit primes are rarer than Mersenne primes.

Patterns like 100000001000000010000000100000001 and 9900990100000000000099009901 are common, both as prime factors and during the long multiplies.

When you do long multiplies of factors of repunits, there is a crest-and-trough feature that shows up a lot, and perhaps there is a tendency for there to be a central zone of the same digit, 0, 2, and 8 showing up above. There may be a trend of sparseness of 3, 4, 5, and 6. These attributes are likely the reason that repunits are prime numbers so rarely, or equivalently that repunits have factors.

Python and other coding languages that offer arbitrary integer precision are important tools to explore the large repunits.

Appendix

How Big, Really, is R1031?

High-school math is barely up to thinking about this. Sorry, middle schoolers. Math professors might be able to get their minds around this. Let’s poke at R1031 and see what we come up with.

The 1031st Repunit, the longest proven-prime repunit, is easily designated by these three short ways:

1031st Repunit
R1031
(10^1031-1)/9

These short forms belie the size of the number! We can be so nonchalant, writing R1031. To insure that the reader does not underestimate R1031, here is the full R1031 written out.

11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111

Let’s be clear about how many numbers there are between R1030 and R1031.

Here is R1030.

1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111

Now, let’s increment R1030, just three times, as if we are going to write every number from R1030 to R1031.

1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111112 Do you see the 2 at the end? That is the incrementing.

1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111113

1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111114

If we continued incrementing all the way to R1031, and printed all that, it would take a stack of paper this tall: 2x101028 inches.

The stack, if measured in miles high, would be 3x101023 miles.

Let’s face it, we really aren’t even scratching the surface of how big R1031 is.

But let’s keep going. The paper stack, our computer printout, could be securely bundled and orbited out into space, all 3x101023 miles of it, and set into orbit around the Sun. Now let’s use side thrusters to lean the stack across the orbit of the Earth around the Sun. That isn’t nearly enough of Space to contain the stack, because the 180x106 miles of the Earth’s orbit (diameter) are exceeded by our paper stack by a factor of 2x101015. At this rate, our paper stack will reach way past the Andromeda Galaxy. And we still aren’t even scratching the surface of R1031.

As we try to visualize R1031, we aren’t getting much of anywhere so far, so try another scenario. Let’s say we could imprint 1000 of our numbers on a single atom. There is no way that could be done, but let’s just imagine there is some quantum way to do it. Then we would need 101031/1000 atoms to show all our numbers. That is 101028 atoms. But you can look up the number of atoms in the universe, it is around 1080 atoms. At this rate, you would need 10948 multiverses to do our counting.

Seven things can be observed, now.

1) Scientific notation is a wonderful tool. 100=1x102 1,000,000=1x106.

2) 101031 cannot be imagined. We can imagine 103, that is the number of pages in a thick book. You can flip through that number of pages in 20 minutes. We can imagine 8x109, the Earth’s population of people. We might imagine 1.3x1050, the number of atoms in the Earth. In the whole Sun, there are 1.2x1057 atoms. Shall we compare to our goal of 101031? There is no comparison.

3) Why do mathematicians deal with such big numbers? This writer doesn’t have a good answer.

4) Look up largest prime repunit at googology.fandom.wiki/Largest_known_repunit_prime, then find on that web site the largest probable-prime repunit. It is R8,177,207, by Henri and Renaud Lifchitz, discovered May 2021. This is far and away larger than our piddling little R1031.

Computer scientists set large computers to work for weeks, testing whether 230-digit numbers are really prime numbers. So they can’t deal with 330-digit prime testing, much less testing the primality of the repunit that is eight million digits long.

5) Max Tegmark, the MIT physicist and AI researcher:

Your DNA stores about 109 bits, while your brain synapses store 1014 bits. JE: Consciousness requires a good bit of 1014 synapses.

“Our physical world not only is described by mathematics, but it is mathematics, making us self-aware parts of a giant mathematical object.”

6) n factorial, n!, is the number of permutations of n objects. If there are five objects, they can be shuffled in 5! = 5*4*3*2*1 ways, 120. If there are 11 objects, they can be shuffled in 39,916,800 ways. If there are 30 objects, there are 2.6x1032 ways. 120 objects, 6.7x10198 ways. In this way, a very countable number of objects can be sorted in 101031 ways. This is a concrete way to think about R1031. 461! is about 1031 digits long (credit to Python).

V = 1

for u in range(1,462):

V *= u

print(len(str(V)))

#takes no more than a few milliseconds

7) If you are thinking about 1014 synapses in your brain, you may as well do some existential thinking. Poke into the Bible, many people have gone from atheism to accepting Jesus’ offer of forgiveness. But you won’t “get it” unless you understand atonement in the Old Testament and see how Jesus fulfilled O.T. atonement.

Document F, continued

Appendix, continued

R105, bigger than the repunits preceding, to see what happens

gr=3*37; gs=31*2906161; gt=41*271; gu=43*239*4649

gv=gr*gs*gt*gu

gw= 10838689; gb= 30703738801; gc=625437743071; gd=102598800232111471

ge= 57802050308786191965409441

perm_list = list(permutations( [gv,71,1933,123551,gw,gb,gc,gd,ge ] )) #9 items, 362880 permutations

Use a threshold of 5.0 in the Python code. It gives 11 interesting, patterned factors.

'4777825556033333333333333333333333285555077773',

'100101111121222223233233333333333332332322222121111101001',

'9235536799812433333333333333333333240977965335209',

{'10827850311000010827861138850321827861138861149678172138861149688999989172149689', '8765343567910000000000000000000000087653435679100000000000000000000000876534356791', '15253055819138710000000000000000000152530558191387100000000000000000001525305581913871', '1931067000000001931068931067001931068931068932998068931068932999999998068933', '123455543210000000000000000000000001234555432100000000000000000000000012345554321', '999000000000000999000999000000999000999000999999000999000999999999999001', '12666390615349595737577161910000000126663906153495957375771619100000001266639061534959573757716191'}

'5303332803000000000005303332803000000000005303332803000000000005303332803000000000005303332803',

R105=a patterned factor * another patterned factor, an interesting combination that had been seen for R40, which also had a palindrome.

Document F, continued

Appendix, continued

In turn, 1109988789001111109989898989900111110998878900111 has these factors: 57802050308786191965409441*30703738801*625437743071, most of the long factors of R105.

This means the palindrome sweeps up all the short factors.

The trend is that longer repunits tend to have increasingly interesting factors. But this may be merely because longer repunits have more factors.

Designer Integers Aren’t Up to Repunits

A naive reader can look at these big multiplies and say, “What is the big deal? I know algebra. If I want some random number 103901 to multiply up to repunit 9, 111111111, is that so hard?” After all, you can experiment and find that 103901*1069=111070169, just a little short of 111111111. Just goose up 1069 a little and maybe it will be 111111111.

But if you goose 1069 up by just one, to 1070, you overshoot. 103901*1070=111174070, beyond 111111111.

Integers don’t have the freedom to “just produce any product you want.” We can creep up on this problem gradually with a story about Claire.

(By the way, my random number, 103901, isn’t a prime number, it is 7*14843. And I did a Python search of all repunits up to R15699 and found no repunit that has 103901 as a factor. This strengthens the statement that integer multiplication can’t produce just any product. And it supports my finding that only certain factors of repunits are the plentiful, periodic factors of repunits.)

A fifth-grade student, Claire, might have a favorite number, 3333333. Her teacher can ask, “I have a favorite, too, my favorite is 1110111. Claire, can you think of a number x to add to my number, which will make your number?”

1110111 teacher favorite

+ x

3333333 Claire’s favorite

Claire might need to experiment on paper, but will soon answer, “Yes, if x is 2223222, it will add up to make my number.”

1110111

+2223222 x

3333333 Claire’s favorite

Claire has designed a “designer number” which can produce a special sum.

If the music teacher’s favorite is 12321, a pretty palindrome, Claire can probably design a y to make 12321+y=3333333.

But if the PE teacher’s favorite is 78987, Claire will be challenged by the carries to find the z in 78987+z=3333333.

When Claire gets to ninth grade, she will know from algebra that finding z is easy, z=3333333-78987. There are borrows, but she could do the borrows even back in fifth grade.

If the STEM teacher says, “Claire, you are showing us that you can do designer adds, but can you do this designer multiply? My favorite is 1111111. Can you design r to make r*1111111 into your favorite?”

1111111

x r

3333333 Claire’s favorite

Even in fifth grade, Claire can probably see that r needs to be 3.

The counselor might say, “If my favorite is 1234321, can you find s to make s*1111=1234321?” If Claire is in ninth grade, her answer will be s=1234321 / 1111. The answer is 1111, to everyone’s surprise.

1111

X 1111

1111

1234321

The principal might say, “I am changing the counselor’s number by just one digit, the 4 changing to 5. Claire, can you design t so that t*1111=1235321?”

Claire might do a short-cut, just changing a one to a two in the last row, shown below in red. After all, we are free to do this with addition, but we will find that we don’t have freedom in multiplication. But let’s see the crash happen. By the way, 1235321 is a prime number, there are no factors that can be multiplied to get 1235321. This is reason for doubt.

Document F, continued

Appendix, continued

If we are constrained to integers, we can’t solve the principal’s problem. If we branch out to decimals, we could do it.

t*1111=1235321

t=1235321 / 1111 = 1111.90009000900090009…

But when we are working with integer multiplier and multiplicand, we are constrained in the products we can produce. The principal has posed an impossible problem.

If the principal had asked for 1236321, that is 9*137369, using factordb.com, the incredible database of factors.

137369

x 9

1236321

(In the following colorful number, it is the seventh factor from R105 patterns, above.)

It does factor, and the factors are 3*3*29*41*313*1949*819001*3611874023...09<60>, the last number being 60 digits. But there is no commonality between the factors of our pretty 1931068… number, not a factor of R105, and the 1931067… that is a factor of R105.

So we were skeptical about finding a way to get our pretty number to multiply up to R105, and indeed it doesn’t work. We should be glad enough for the patterns that we do find, multiplying various permutations of the prime factors of R105.

End of Document F

Document G

At the end of Document F, it suggests we should be glad there are patterns in repunit factors. It implies we don't know why there are patterns. Document G finds some reasons. We are making progress because of the following code.

# longMultVer7.py for repunit work JE Dec 9 2021

# clean up code some

# Code to mimic a person doing long multiply

# To look for reasons that repunits rarely are prime numbers

# it is working for i=123432147656734567 j=str(987767659876)

#i= #for R127 but interchange i and j

#j=str(18797*90679)

#i= ((10**127-1)//9)//int(j) #for R127

i= 18797*90679

j= str(((10**127-1)//9)//i)

jlist=list(j)

prodList=[]

#for each digit in j, starting with LeastSignificatDigit, mult by i & put in string in a list

periodCounter=0

for r in range(len(j)-1,-1,-1):

#print( r, jlist[r])

prodList.append(str(int(jlist[r])*i) + '.'*periodCounter) # list of strings

periodCounter += 1

print(jlist[r],prodList)

#so far, prodList has the lined-up rows with trailing place holders, ready for addition of columns

for s in prodList:

print(s)

prodListLength=len(prodList) # the number of rows to be added

print (prodListLength)

#prefix placeholders to make all rows same length

u9 = [] # lengths of each row, in a list

for t in prodList:

u9.append(len(t))

print(u9, 'the longest row has ', max(u9))

u11 = []

for t in prodList:

u13=t

while len(u13)<max(u9):

u13='.'+u13 #prefix a placeholder

u11.append(u13)

# u11 has uniform-length strings ready to be added, with period place holders

for r in u11:

print(r)

#build up a list of carries while columns are added

carryList=[0]

sumList=''

#print( 'len(u11[1])-1 ', len(u11[1])-1)

carry=0 #starting the meat and potatoes of the algorithm

for r in range(len(u11[1])-1,-1,-1): #range horizontally, least significant digit first

colSum=carry

for s in u11: # range vertically

#print('s ',s, ' r ',r)

if s[r].isnumeric(): #skip place holder periods

colSum += int(s[r])

colSumString = str(colSum)

sumForThisColString = colSumString[-1] # colSum's least signif digit

sumList = sumForThisColString+sumList

if len(colSumString)>1:

carryString = colSumString[:len(colSumString)-1] # any other digits

else:

carryString = '0'

carry=int(carryString)

#print( 'colSumString, carry, sumForThisColString ',colSumString, carry, sumForThisColString )

#throaway=input('pause')

carryList.append(carryString) # at the end, get an idea of what the carries were

if int(carryString)>0:

sumList=carryString+sumList #if there is a lingering carry, take care of it

print('product , carryList but read it backwards', sumList , carryList )

print('proper product ',i*int(j))

print('i = ',i, ' j = ',j)

if int(sumList)==i*int(j):

print('Answer of product is correct')

The code lets us see the long multiply of certain of the factors of R43.

518970226475059768335671

2140992015395526641

t,,,,,,,,,,,,,,,,,,,

...................518970226475059768335671

.................2075880905900239073342684.

................3113821358850358610014026..

...............3113821358850358610014026...

..............1037940452950119536671342....

.............2594851132375298841678355.....

............2594851132375298841678355......

...........4670732038275537915021039.......

..........1556910679425179305007013........

.........2594851132375298841678355.........

.........518970226475059768335671..........

...............................0...........

......1037940452950119536671342............

.....4670732038275537915021039.............

....4670732038275537915021039..............

...........................0...............

..2075880905900239073342684................

..518970226475059768335671.................

1037940452950119536671342^^^^^^^^^^^^^^^^^^

1111111111111111111111111111111111111111111

carryList but read it backwards [0, '0', '1', '2', '2', '1', '2', '3', '3', '4', '4', '5', '5', '5', '7', '6', '6', '7', '8', '10', '8', '8', '7', '8', '9', '6', '8', '7', '6', '5', '6', '5', '5', '4', '4', '2', '2', '3', '3', '3', '1', '1', '0', '0']

There isn't too much spectacular, here.

R60

24000135111222222222222222222198222087111

4629603566654784001

..................24000135111222222222222222222198222087111

.........................................................0.

........................................................0..

...............96000540444888888888888888888792888348444...

.............192001080889777777777777777777585776696888....

............168000945778555555555555555555387554609777.....

............96000540444888888888888888888792888348444......

..........120000675556111111111111111110991110435555.......

.........144000810667333333333333333333189332522666........

........144000810667333333333333333333189332522666.........

.......144000810667333333333333333333189332522666..........

......120000675556111111111111111110991110435555...........

......72000405333666666666666666666594666261333............

.............................................0.............

...144000810667333333333333333333189332522666..............

..216001216000999999999999999999783998783999...............

..48000270222444444444444444444396444174222................

144000810667333333333333333333189332522666.................

96000540444888888888888888888792888348444^^^^^^^^^^^^^^^^^^

111111111111111111111111111111111111111111111111111111111111

Product , carryList but read it backwards 11111111111111111111111111111111111111111111111111111111111 [0, '0', '0', '0', '1', '2', '2', '3', '3', '4', '5', '6', '5', '5', '5', '6', '6', '7', '8', '9', '9', '8', '8', '9', '8', '8', '8', '9', '8', '8', '8', '8', '8', '8', '8', '8', '8', '7', '7', '8', '7', '8', '7', '6', '6', '7', '6', '4', '3', '3', '3', '2', '1', '2', '1', '1', '1', '1', '1', '1']

proper product 111111111111111111111111111111111111111111111111111111111111

i = 24000135111222222222222222222198222087111

Strange absence of carries over 9.

A weak 7-8-9 waterfall pattern.

No matter what a string of 2s is multiplied by, 0-9,

the product has a string of some number.

Here is the matchup.

0x gives 0s

1x gives 2s

2x gives 4s

3x gives 6s

4x gives 8s

5x gives 1s

6x gives 3s

7x gives 5s

8x gives 7s

9x gives 9s

a curious pattern, this is probably a generally applicable explanation for why strings of numbers crop up

R127 only 3 factors

651871849785243820958119684233142982170536938147349501049955875423544371888519632103159753836519854149224951224466197

1704493163

........1955615549355731462874359052699428946511610814442048503149867626270633115665558896309479261509559562447674853673398591

.......3911231098711462925748718105398857893023221628884097006299735252541266231331117792618958523019119124895349707346797182.

.......651871849785243820958119684233142982170536938147349501049955875423544371888519632103159753836519854149224951224466197..

.....1955615549355731462874359052699428946511610814442048503149867626270633115665558896309479261509559562447674853673398591...

....5866846648067194388623077158098286839534832443326145509449602878811899346996676688928437784528678687343024561020195773....

...2607487399140975283832478736932571928682147752589398004199823501694177487554078528412639015346079416596899804897864788.....

..2607487399140975283832478736932571928682147752589398004199823501694177487554078528412639015346079416596899804897864788......

......................................................................................................................0.......

4563102948496706746706837789632000875193758567031446507349691127964810603219637424722118276855638979044574658571263379........

651871849785243820958119684233142982170536938147349501049955875423544371888519632103159753836519854149224951224466197.........

product , carryList but read it backwards 1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111

[0, '0', '1', '2', '2', '3', '4', '5', '5', '5', '4', '5', '4', '5', '6', '5', '4', '4', '6', '5', '5', '5', '5', '6', '5', '5', '4', '5', '5', '5', '4', '5', '5', '5', '6', '4', '4', '5', '4', '5', '5', '5', '5', '4', '4', '5', '5', '4', '4', '5', '4', '5', '4', '5', '5', '4', '4', '3', '5', '6', '5', '5', '5', '5', '4', '4', '4', '5', '5', '5', '4', '3', '4', '4', '4', '5', '5', '4', '4', '3', '3', '4', '5', '3', '5', '6', '6', '5', '6', '5', '5', '4', '6', '4', '3', '5', '4', '4', '5', '6', '5', '6', '4', '4', '5', '5', '4', '4', '5', '5', '6', '6', '3', '4', '4', '6', '5', '5', '6', '5', '4', '2', '2', '2', '1', '1', '1']

proper product 1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111

i = 651871849785243820958119684233142982170536938147349501049955875423544371888519632103159753836519854149224951224466197 j = 1704493163

a weak pattern of 9 waterfall but not apparent with 8 or 7

Return to the R194 that started this web page

Document G, continued

These are the most interesting patterns seen when certain factors of R194 are multiplied up.

Patterns may be nice, depending on your taste. Let's get back to the long multiplies. Choose Repunit 127 to look at. When we multiply certain factors, and include them all so we get R127 at the end, look what pops up. We have chosen to do a multiply of a short number by a long number. (Sorry, the image cuts off a little on the right side.)

Only the beginning of the long multiply is shown below. Each column does indeed add up to all ones. Whereas Document F has a section Designer Integers Aren’t Up to Repunits, it appears that a designer product can be done, after all, or is at least in the realm of feasibility, if the multiplicand is short. For each column that we add, only 11 digits are added, and we can select the next number leftwards in the multiplier to produce a designer product of all ones. Of course, it is more than feasible, because we knew ahead of time that R127 is the product of the factors we are playing with.

If we call the above clue, long multiplier and short multiplicand, Clue #1, then Clue #2 about why repunits are rarely prime is that many-factored repunits are plentiful in factors such as 11*101=1111 and 239*4649=1111111. These all-ones factors coordinate with factors like 10000000100000001 to crank out longer and longer all-ones factors. Clue #3 is the R60 section, above, where it is found that mid-product strings of 000000000, 11111111111, 22222222, etc. can be self-sustained once a string of 0, 1, or 2 crops up in a multiplicand. Clue #4 is the crest-and-trough behavior that is sometimes seen. Clue #5 is alternating digits that are seen to clump together. 0 1 2 3 4 5 6 7 8 9 The colored pairs, mirrored at the middle, are the ones most often seen, as in 90909090 (by far the most frequent, but often seen as 900900900900990990990991), 2727272727, 363636636, and 4545454545. Notice that 9+0=2+7=3+6=4+5, sort of palindromic. I don't see 181818. Clue #6 is the palindromes. Someone with higher thinking power can probably fold these clues together and show they are parts of a whole, and this may actually have been done on the Internet but is cloaked in math.

Document G, continued

R194 in terms of the final multiplication of one factor, 846035731396919233767211537899097169

by the product of the other factors (which includes the shocking factor 10000...00001). This product retains a zone of 000000000.

product 11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111

carryList but read it backwards

[0, '0', '1', '1', '2', '1', '3', '3', '3', '3', '5', '6', '6', '8', '7', '8', '7', '8', '10', '11', '11', '11', '11', '12', '11', '13', '11', '16', '14', '14', '17', '18', '18', '16', '16', '21', '19', '18', '19', '20', '20', '18', '21', '18', '18', '20', '17', '20', '15', '19', '17', '19', '16', '17', '19', '17', '16', '18', '15', '17', '16', '17', '15', '16', '17', '14', '15', '15', '15', '14', '15', '12', '13', '11', '11', '11', '11', '9', '10', '10', '7', '7', '8', '8', '5', '6', '5', '4', '5', '4', '4', '3', '2', '2', '1', '1', '0', '0', '0', '1', '1', '2', '1', '3', '3', '3', '3', '5', '6', '6', '8', '7', '8', '7', '8', '10', '11', '11', '11', '11', '12', '11', '13', '11', '16', '14', '14', '17', '18', '18', '16', '16', '21', '19', '18', '19', '20', '20', '18', '21', '18', '18', '20', '17', '20', '15', '19', '17', '19', '16', '17', '19', '17', '16', '18', '15', '17', '16', '17', '15', '16', '17', '14', '15', '15', '15', '14', '15', '12', '13', '11', '11', '11', '11', '9', '10', '10', '7', '7', '8', '8', '5', '6', '5', '4', '5', '4', '4', '3', '2', '2', '1', '1', '0', '0']

it is the proper product 11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111

Here are the two numbers being multiplied to get R194.

i=13133146389414506547917991437836028423242548326663322910921190000000000000000000000000000000000001313314638941450654791799143783602842324254832666332291092119

j = 846035731396919233767211537899097169 36 digits

Answer of product is correct

The center-0 area is just enough to let the problem do an exact repeat.

The non-zero area of i has a crest-trough look, 3 crests. 8, 22, 45 digits from the 13133 end of 57 digits, doing 5-digit moving avg. But the look of the yellow 7-8-9s in the sub-products is only slightly cresty-troughy.

Take a look at the center-zero area, zooming in on it.

Here is a zoom on the center-zero area, with red fills marking the column with leftmost digit of the right area, with purple fill, at the bottom line, and the next-left column has a 1 with purple fill on the top line. I expect there is going to be a longer repunit that has two zero areas, each 36 zeros in width, not one, and a third incidence of 1313314638941450654791799143783602842324254832666332291092119 (61 digits) in the multiplicand. This speculated repunit should have a length of about 36 digits at the right, then 61, 36, 61, 36, 61, for a total repunit length of about 194+97=291 digits. When I look in Mr. Kamada’s repunit web site for R291, I see only two of the seven factors of R194, so I am not understanding all that is going on, but there is likely the presence of two zero-areas (each 36 zeros) in some order of factor multiplication of R291. Fact: 291/194 = 1.5, nice and neat.

If 194*1.5 has some factors of R194, 194*2 should have some factors. At 194*2=388, R388, I find all the factors of R194, plus more factors needed to make R388. And R388 should have three zero areas.

Document G, complete

Document H

This document shows a way to use Mr. Kamada's amazing web pages with repunit factors to find the "probable-prime yellow factors" that he merely hints at, but he doesn't show the full yellow factors, he merely shows the first 10 digits. An example is R801, the repunit that is all ones, 801 of them. And I include the next repunit, R802. These are from his Page 9.

R801 = 10801-1/9 = 1111111111...<801> = 32 × 37 × 9613 × 333667 × 352441 × 497867 × 103733951 × 1087283809<10> × 104984505733<12> × 540913940517169<15> × 6505946816292037450243<22> × 5078554966026315671444089<25> × 403513310222809053284932818475878953159<39> × 17325664671184692265593556093236354753889091916984839786843373136949346408767908517386284403996865926210851082169755833546074754110413766826738528679977268603<158> × [4007058050...<492>] (38.55%)

R802 = 10802-1/9 = 1111111111...<802> = 11 × 4813 × 16843 × 26914319 × 12061085521<11> × 4488792458298882059329<22> × 25630835501493582366342771676602359<35> × 2971245460182291007178927517460929280931723051<46> × 14135641046765185164159467932114646984359158253<47> × [6765133553...<308>] × [1174186273...<320>] (21.74%)

As I said, Mr. Kamada shows just the beginning of the yellow numbers, which, by a key on his first page, are probable prime numbers. Why he doesn't give the full yellow numbers, I don't know. But if you click on the yellow, he takes you to a page of "Cyclotomic factors," whatever that is. But it still doesn't give these full factors.

Before going on about the R801 probable prime, which he says is 492 digits long, let's note that R801 is only 38.55% factored, which is the last part of the R801 printout, shown here in purple. Many numbers over 200 digits, ending with 1, 3, 7, or 9, takes a long time to factor, and most of these yellow numbers in Mr. Kamada's web site may never be fully factored.

Also note that R802, shown above, has two yellow factors. I am going to use Python to find the R801 yellow number, all 492 digits of it. The Python code is short and simple, merely dividing R801 by all the other factors. This approach is no use for R802, this Python technique only works to find one unknown factor.

The Python code:

# repunit 801 Kamada v1.py

a=[3,3,37 ,9613 ,333667 ,352441 ,497867 ,103733951 ,1087283809,104984505733 ,

540913940517169 ,6505946816292037450243,5078554966026315671444089,

403513310222809053284932818475878953159,

17325664671184692265593556093236354753889091916984839786843373136949346408767908517386284403996865926210851082169755833546074754110413766826738528679977268603]

print(a, len(a))

#print(a[0])

for b in range (0,len(a)):

print(a[b], len(str(a[b])))

prodb=1

for b in range (0,len(a)):

prodb *= a[b]

print('prodb ',prodb, 'length',len(str(prodb)), 'expect last factor of R801 to be about this digits',801-len(str(prodb)))

e=''

for d in range(0,801):

e = e+'1'

e=int(e)

print(e,len(str(e)))

print('mod ',e % prodb)

f=e//prodb

print('last integer in R801',f,'length',len(str(f)), 'Kamada says it is a probable prime')

#check

print('check',f*prodb, len(str(f*prodb)))

The a variable is merely a list of the factors that Kamada gives in full. The list is easily formed by copying and pasting text from Kamada's web page and changing all multiply symbols to commas. Most of the code shown above is checking and hand holding to be sure everything looks right.

The crux of the code is forming the 801-digit repunit by appending 801 ones, giving a string, then change that to an integer. Then divide it by the product of the other factors, which is the variable prodb.

The answer is the f variable, which in this case is 492 digits long. It is...

last integer in R801 400705805095492102381335512117462320784469304466979217132721623330172658890957848800374853939713111280719377171873415278306999431686257468215797437482855528619976030355167951737012573259587524445924377646593279647883453313500413222600040507503888281925186539217102716216914746202063760659533958944199912063780786207027551190424054181061184128127616114455668544148414027752132867971819443454066849074288404834014856884880749963639942831477650444061201391975401585556345369172599055133481196203 length 492 Kamada says it is a probable prime

This number does in fact multiply up with Kamada's other factors to give 801 ones. Great. And it matches the yellow 4007058050..., as far as the yellow number goes. And this 492-digit number ends in 3, which is among the required end-in-1, 3, 7, or 9 that is one requirement for a prime number.

Now, a further question is from Document A, can factordb.com be used for R801? And R802! For R801, yes, it works. And R802 works, it takes 75 queries but only .01 second. The more information click shows R802 was factored by factordb.com in 2018. Both yellow factors are available by two clicks each.

Do the Python code for a larger repunit, R4219. The single yellow factor, a probable prime, is

26888693717405300937546797701407180539849865366618655184800625038495174209620289755215335428582956328295229314910759992525746038348538773842467033705915056961548495110135742771282966199055583129894953226139489818333330084318416344526029618321525680283384346085395603102856813651772365164960724215265219804988223145816265375902619520965498218619919990406840121015713750025700018366532475876020815461611130105143252193871578664273136718256537204063286628166406802934720139380362578898611911268911708398478731493885151160777582245494175673578301933310754151628203145629875513762137977481715308400139618693199244421462980451114616447213784308276083868224085539367518858808882841730684203732319791500607180056073939896404944708147321879352940305736239045148801195631906468495879712318938418705397874043599465522301320053736371065272575911664660662833425791331837924392763900030281490587624718540443785134353050723994725222913644930593802373975313025920747353225885485120011757335089833526168875001913950075821689639477642200434646338237264084891356298692304668414189569823844340776094193370925783826893422029078700655725784370046139024484996381164915548574770178586220219158577875546433349571117456103719002015506244464637977146014628672620688728157380800831165836276384203839681901059051130091058851340237348059773499724758279569110946839139035341008665141300453179468298939949372373364720282855151676273623574348789193580013459287824766004056353835750804222720480396521169283271279999180389570749875723426505448927834087233453439993191276939119089175011565212686691627721216434898448653701064182111510177287677333109746309697407578459996083181677996684289196046692177639456040106315521148099624521572400898569474237944857615147003982179265220250682942274805147596295901715722361687037669020864057804029112279535398473847420136232117575367386052632883515705209374879489701292426878885671651630692631546338527375135082808187606144871290743649611067915315921276187063137694547565612531116030678137355159757493945075704814749395817782951084771423886164094330827445106074288073228189454623353368790905203455574160013106187339014369608807737548537405136430021377935881324677586102789974300958569868952996248959367554672715640569524204736822441337061908461461180980025182516261625200041742512215933675954863684570167706815488850832934802720408867097520151022896248283863578744644367819463810670792822555877442732210952462855696946958037452008243957762631523355199610967898831907541790047822670817300143995361605484750105689551713904962780120521244447425525229275444643798324966504290880052854236992867681662616275242764357352015090745232255029523449511597800909644045151149624957281821075290618983997115755890687201984700267211345330512330376515002941423575238950104542055146123017432801755036914618005245106553985969308452217712765459687971758335795722933312254200356123023949779508343895183787647008823173646408590515796765070664274450445308112598319172468674512029325397332955933121536346680892879697633204701620789632932351234635373421210966854639286189131643291999084997554174063525391606764425446290764480463986864537998043453147219524553213614987889205931867896601854413161914286548607352030066977410825897403998310957802647945248726890527806573957955147148426895919345378940227772864850322288391646113669332914893813307167489053532868786468852262281727229608233143126417129160798555173075164788976869558725080142054556425148198738930436542283028462427131819702409015424412372863582652937181464850582031668180791633178782665336118623614865492659861886271904479221480568991726430321145411189227714784659751411115471796324448701056577017569454439026282038727536646019932816645583871175375127841794823588629154958255067383059193159940725610753509307716643874833670075597860671150918409604697646708712032810472608316657455121378298338299873459759761988221424023544125292974281706953933729179891593395817138366262862683180848943956727777356153006512817016014529248118094375418465303437258116333589218004723893282510901575813207210182791785925434324995864696515068663540218475405277772094260200284694669585828691912651344716048670815992424126604468220027744350749086817121

which is 4163 digits. This is near the limit for Thonny to convert a string to an integer. The code is on HP laptop, repunit 4219 Kamada v1.py. I took this factor and the product of the other two factors that Kamada fully gives, took only the lowest 25 digits of each, and started a long multiply to prove that it does indeed give all ones, at least at the low end. Yes, it does.