On 7/2/2021 12:14 PM, Kcir wrote:
> So if we say a zipped program we want to send is a stream of numbers but one large number, how can we compress it if it is already compressed? So then add 3 zeros to its length as a large number using power of 10 so as an example 1,000 it has to have a 1 and all zeros, 10 to the power of 40 million as an example, now divide the large number into that and use exponential notation every time you make your large number or refer to it. As you create your formula that will recreate that large number as its result or answer.
>
> So this is a fun math project for math hungry people.
>
> Hint? Adjust the number as part of the formula so that it falls into an algorithmic pattern that can use exponential notation. All theory at this point.
> Have fun and spread this puzzle to your friends.
>
> I inwented it, I am the Rickest Rick of all the Ricks if anyone wants to know who inwented it.
>

Are you familiar with arithmetic encoding:

https://en.wikipedia.org/wiki/Arithmetic_coding

?

On Friday, July 2, 2021 at 8:02:41 PM UTC-7, Chris M. Thomasson wrote:
> On 7/2/2021 12:14 PM, Kcir wrote:
> > So if we say a zipped program we want to send is a stream of numbers but one large number, how can we compress it if it is already compressed? So then add 3 zeros to its length as a large number using power of 10 so as an example 1,000 it has to have a 1 and all zeros, 10 to the power of 40 million as an example, now divide the large number into that and use exponential notation every time you make your large number or refer to it. As you create your formula that will recreate that large number as its result or answer.
> >
> > So this is a fun math project for math hungry people.
> >
> > Hint? Adjust the number as part of the formula so that it falls into an algorithmic pattern that can use exponential notation. All theory at this point.
> > Have fun and spread this puzzle to your friends.
> >
> > I inwented it, I am the Rickest Rick of all the Ricks if anyone wants to know who inwented it.
> >
> Are you familiar with arithmetic encoding:
>
> https://en.wikipedia.org/wiki/Arithmetic_coding
>
> ?

Totally in fact have my own encryption you take a photo outside /7 * 3 +8 or any scramble you want until it cannot be recognized as a photo on disk, then you merely add or subtract or multiply or divide your data stream number for number. and then at the other end they just need that photo which could be only important to you and one of a thousand on your harddrive.

You can make a black box modem with a matching one photo in each and then self destruct with magnesium if the container is breached.

> > Are you familiar with arithmetic encoding:
> >
> > https://en.wikipedia.org/wiki/Arithmetic_coding
> >

> Totally in fact have my own encryption you take a photo outside /7 * 3 +8 or any scramble you want until it cannot be recognized as a photo on disk, then you merely add or subtract or multiply or divide your data stream number for number. and then at the other end they just need that photo which could be only important to you and one of a thousand on your harddrive.
>
> You can make a black box modem with a matching one photo in each and then self destruct with magnesium if the container is breached.

So a server sends your phone a photo and it says this is your key.
And then you download a stream of data and you decode it as it comes in using your photo as a key.

Now where you put your photo will depend on how safe your data transfer is. So you should put it on a small stick like a USB drive and then only plug that in when the software needs your photo.
Then remove the drive and it can instruct you to do that. So if it was gov they might hand deliver the USB drives that have the photo on it.

So now at both ends the stamps are secure on usb drives the evidence is removed to protect from hacking.

However it will not stop spying. So an admin would rotate the formulas for scrambling the images by entering their photo to mix it up and everyone gets a different outside image.
So each method is unique since any photo taken outside is unique providing you photograph a multi colored scene or garden etc.
No supercomputer or quantum computer could guess that photo.

If it popped a billion photos it made itself no one would be there to say that must be it.

And you couldn't try them all simply because the formula to scramble them first keeps changing.
According to the primes and the Reimann hypothesis. Or similar by the time an academic is finished with it.

But regarding the theory to reverse engineer a large number as if it were a biological end process, so you add 6 zeros to the w

in this case w=1000000000000
x=123456000
So we added 6 zeroes to w and we will just use exponential notation there when the time comes to say what number that is.
w=10 ^12
it could easily be 10^690m (m for million)

So here we have a remainder when we try to find a small divisor but we slough that off with the extra zeros.
w=1000000000000
x=123456000

w/x=8100.051840331778

We have right there reduced 6 digits to 4 digits.
w/8100 =123456790.1234568

and all we want are the original 6 digits which are accurate.

Ok so closing in on using this with large numbers.

x=1234567898765432 (16 digits)
w=10000000000000000000000 (22 zeroes so we want x to be 6 short )
we factor up x to ditch the end of the code in micro biology believe it or not they don;t terminate a string some times they just repeat a bit of code and that sometimes creates a problem.

Huntingtons Chorea.

Huntington's disease (HD), also known as Huntington's chorea, is a neurodegenerative disease that is mostly inherited. The earliest symptoms are often subtle problems with mood or mental abilities. A general lack of coordination and an unsteady gait often follow.

In people with Huntington disease, the CAG segment is repeated 36 to more than 120 times. People with 36 to 39 CAG repeats may or may not develop the signs and symptoms of Huntington disease, while people with 40 or more repeats almost always develop the disorder.

A sad situation for those who discover they have this incurable disease.

So the math anyway is consistent with the idea that their may be remainders and they may not affect the process or they may.

So in our case where we are looking at a zip file 40mb and we are looking at that stretched out data as a large number.

We are going to create an exponential notation and say 10 to the power of 40m or similar then we are going to add 6 zeroes.
so 40m plus 6
That will always be the case so the program would know that
and then you are going to add 3 zeroes to x and then divide x into w and you will get a small number dude.

yippee ei o ki yay

Eureka.

Yes if it was gov admin that wanted to encrypt a file and send it to a home worker, they have a USB device and on there a picture of you outside with your name on the picture.
So then on her USB drive she has all the staff pictures and their names in similar fashion.
So when she sends you a file then you use your photo to decrypt it that you keep on your usb drive.

So admin needs to know who they are sending it to and then it is completely secure and hack proof.
They can intercept the data but they would never be able to separate the data from the photo.
So every transmission since the data changes the transmission changes.

If they try to match up portions to decrypt a portion of the file if you are sending repetitive data they would still be nowhere.

So these bits are the same these bits are still meaningless.

On Friday, July 2, 2021 at 9:15:42 PM UTC-7, Kcir wrote:
> Yes if it was gov admin that wanted to encrypt a file and send it to a home worker, they have a USB device and on there a picture of you outside with your name on the picture.
> So then on her USB drive she has all the staff pictures and their names in similar fashion.
> So when she sends you a file then you use your photo to decrypt it that you keep on your usb drive.
>
> So admin needs to know who they are sending it to and then it is completely secure and hack proof.
> They can intercept the data but they would never be able to separate the data from the photo.
> So every transmission since the data changes the transmission changes.
>
> If they try to match up portions to decrypt a portion of the file if you are sending repetitive data they would still be nowhere.
>
> So these bits are the same these bits are still meaningless.

Here is some code

4032 x 3024 photo

name of function
variables
i,j,k,l:integer;

For j:= 0 to 3024-1 do
for i:=0 to 4032-1 do
read byte from disk, add byte from photo write sum to disk.

If you still have data and you have reached the end of your photo pixel values which are 3 numbers 0 to 255
red blue green so you are adding the red value then the blue value then the green value like that to the data stream and saving the result in the same linear fashion.

so you say if not end of file (your data file) then start the pic over and repeat it.
So you want to return a function call so you can just call that function over and over and trigger it off if a boolean switch is flipped then break your iteration code and be sure to check for activity like process messages if you are using WIndoze.
So you can interrupt it if need be or else it might be going through there and ignoring you.

So function dothethang(on:boolean):boolean;

So here we just installed two switches, one that inside the brackets and one that is what the function returns true or false.
It could return a number also.

So when you call that function it will take the last point in the data and go from there but only if you add a variable that keep tracks of that.

So then you need
function dothethang(on:boolean;fnum:double):boolean;

The biggest/largest integer that can be stored in a double without losing precision is the same as the largest possible value of a double. That is, DBL_MAX or approximately 1.8 × 10 ^308 (if your double is an IEEE 754 64-bit double).

So you know where you are in the file and each time you save a byte you want to increment where you are in the file so you are
moving through the bytes and can repeat the photo from the beginning and just keep motoring through that file.

As long as at the other end they merely reverse the process.

So now you have changed every number your double or your integer or your word by changing the data by adding a red color value a green color value and a blue color value as you motor through the data. Now you need to first scramble the image or else any 0 value will show the image when you add zero.

So first you apply three steps like div 7 times 3 plus 8 and now to each pixel and it now is white noise only colored white noise.
So if you add a zero from your data it will still look like colored noise.

So the software prompts for your USB says please insert your usb, you do it takes the photo scrambles it and then processes the data and the sends the data. It says please remove your usb drive.
At the other end it says please insert your usb drive.
It gets your photo and so then it knows that it has been scrambled and so it does that and now it subtracts that from the data stream.
Then it asks you to please remove your usb drive.

Simple as that.

On 7/2/2021 9:43 PM, Kcir wrote:
> On Friday, July 2, 2021 at 9:15:42 PM UTC-7, Kcir wrote:
>> Yes if it was gov admin that wanted to encrypt a file and send it to a home worker, they have a USB device and on there a picture of you outside with your name on the picture.
>> So then on her USB drive she has all the staff pictures and their names in similar fashion.
>> So when she sends you a file then you use your photo to decrypt it that you keep on your usb drive.
>>
>> So admin needs to know who they are sending it to and then it is completely secure and hack proof.
>> They can intercept the data but they would never be able to separate the data from the photo.
>> So every transmission since the data changes the transmission changes.
>>
>> If they try to match up portions to decrypt a portion of the file if you are sending repetitive data they would still be nowhere.
>>
>> So these bits are the same these bits are still meaningless.
>
> Here is some code
>
> 4032 x 3024 photo
>
> name of function
> variables
> i,j,k,l:integer;
>
> For j:= 0 to 3024-1 do
> for i:=0 to 4032-1 do
> read byte from disk, add byte from photo write sum to disk.
>
> If you still have data and you have reached the end of your photo pixel values which are 3 numbers 0 to 255
> red blue green so you are adding the red value then the blue value then the green value like that to the data stream and saving the result in the same linear fashion.
>
> so you say if not end of file (your data file) then start the pic over and repeat it.
> So you want to return a function call so you can just call that function over and over and trigger it off if a boolean switch is flipped then break your iteration code and be sure to check for activity like process messages if you are using WIndoze.
> So you can interrupt it if need be or else it might be going through there and ignoring you.
>
> So function dothethang(on:boolean):boolean;
>
> So here we just installed two switches, one that inside the brackets and one that is what the function returns true or false.
> It could return a number also.
>
> So when you call that function it will take the last point in the data and go from there but only if you add a variable that keep tracks of that.
>
> So then you need
> function dothethang(on:boolean;fnum:double):boolean;
>
> The biggest/largest integer that can be stored in a double without losing precision is the same as the largest possible value of a double. That is, DBL_MAX or approximately 1.8 × 10 ^308 (if your double is an IEEE 754 64-bit double).
>
> So you know where you are in the file and each time you save a byte you want to increment where you are in the file so you are
> moving through the bytes and can repeat the photo from the beginning and just keep motoring through that file.
>
> As long as at the other end they merely reverse the process.
>
> So now you have changed every number your double or your integer or your word by changing the data by adding a red color value a green color value and a blue color value as you motor through the data. Now you need to first scramble the image or else any 0 value will show the image when you add zero.
>
> So first you apply three steps like div 7 times 3 plus 8 and now to each pixel and it now is white noise only colored white noise.
> So if you add a zero from your data it will still look like colored noise.
>
> So the software prompts for your USB says please insert your usb, you do it takes the photo scrambles it and then processes the data and the sends the data. It says please remove your usb drive.
> At the other end it says please insert your usb drive.
> It gets your photo and so then it knows that it has been scrambled and so it does that and now it subtracts that from the data stream.
> Then it asks you to please remove your usb drive.
>
> Simple as that.
>

Please, post this over in sci.crypt!

So different programmers do things differently.

But you could calculate 4032 x 3024 = t;

So then what size is your file? So file size div t so you know how many times you need to repeat the image.

You don't want to use a while statement since that sometimes gets screwed by Windows and it just decides to skip that.
And leave you hanging.

So you want to always give it a number of iterations. Don't rely on Windows to say oh you reached infinity?

so fsize/t = num and so then
for k:= 0 to num -1 do
dothethang(on,0);

So you are telling it to only do it as many times as are needed since you know how many times it will repeat.
Its not an unknown so don't be lazy do the math.

Sorry but Friday and I am late picking up my girlfriends.

So use any of it you want and may the force be with you!
Publish or perish!

On 7/2/2021 10:20 PM, Kcir wrote:
> Sorry but Friday and I am late picking up my girlfriends.
>
> So use any of it you want and may the force be with you!
> Publish or perish!
>

https://youtu.be/7YvAYIJSSZY?list=RDMM

For the win

1234567898765432123456789

That's a bitch of a number to divide in your head into 1 million quadrillion or something.

And if we intend to take numbers with 40 million digits and divide them into numbers with 40 million and 3 digits.

So do this and see how fast and easy it is so you can do this in your head no seriously in your frickin head.
notice it is an odd number so we will use a formula and when we are done, our little algebra formula is going to result in that large number in all it's glory so that to send and entire 40mb program through a network, you will go oh that here you go.
a*b=c+d=e.
WTF???
Easy as pie first remove one so it is an even number.

minus 1
1234567898765432123456788
div2 do that in your head you are a genius easy to do.
see? Now keep doing it and doing your minus 1 and list your operations then what do you have?

think about this. How may of those div 2 can you group into a div 6 or a div 8?
then your remainder.
You have to write a computer program since no other way exists to deal with very large numbers yet, but people have written programs but we can make our own and maybe improve on them.
Like I know by looking at that number the first 4 digits that if I want to divide that into 40mb 1 and 40m zeroes the first 4 digits are the most important. The rest aren't going to do much if the number you divide into has 3 more zeros on the end of it. Which means your answer is going to have 3 or 4 digits.
And then one hell of a lot of decimal places.
81.02
So we multiply that by 81.02 to see what we get.
Our calculator in Windows can't use a number that large as above it only got to 2 7 digits short but those aren't important right now.
1.000246911579753e+17

So with 81.02 we managed to gt 3 clear digits. We got rid of the large numbers and our remainder is still a gazillion digits long.
Our program could try to eliminate more digits sequentially. But I am thinking the minus one div 2 formula is going to shrink that number substantially so yeah how many times would you have to multiply a number by 2 to get close? Factors or two.

So you start your computer rolling and you say compare the result to this large number but that is going to take too long.
So the way to approach it is to use maybe 4 digits at a time on the left and work with remainders as separate operations in a chain reaction formula.

What is my point?

Well this number we can use a short form notation easily.

1000000000000000000000000000000000000000000000000000000000000000000000000000000000

right? And that can go on for 40 million digits. And we can still say 40mb and that is exact, precise and the actual value not an approximation.

Now what is going to happen if I divide that number by 81.02?
I am going to get an approximation of my program data stream large number which is random.

So you need to instead build a chain reaction that will get you to that number using times two. You want a short form notation using times 2 that will remove most of those digits.
Will that imitate all those values in those digits since they must all be exact you see.
Its a wonderful puzzle and so much else has been done so that is why I am having some fun with it.

Well there are things we can try and approaches we can take.

We could look at the number we want to divide into 1000 and say is it less than half that or more than half that and use calculus ideas to find the middle so you are close to it.
Get its rough boundaries does that remove digits though? So your only solution is to get zeroes in a row from the left and reduce the digits.
You might end up with an algebra expression with a million brackets but 1 mb is still substantially smaller than 40mb.

Pure math pure science and using computer programming so you don't have to write that algebra expression and do it in your head.
So will chain results and not use brackets and write instructions on the fly as part of our compressing the data.
And it is not so much for compressing the data.
It is to learn about going the other way.
Growth and these types of systems in DNA go the other way. But we can;t tell where they are going yet. We see it here and something change over there.
In the brain usually.
We don't know what it does between A and B quite often so we don't know the result of tampering with A until we see what it does to B.
The problem there is the slow reaction time of B and what else has moved or changed.

Growth and cell division and DNA replication is using 2 all the time so we should also use 2.

So if we look at our zip file as a stretch of 40m random numbers and we want to use a formula using 2 to recreate that number.

So if we divide it by 2 that helps a lot right? That lops off half the digits right? Sadly no it does not change the number of digits except for one if you are lucky.

And slowly by slowly once you have a list of OPERATIONS that amount to half those digits then you have gone through one pass of the data.

However maybe we can establish a pattern for those 20 digits of our formula..

Or maybe try a different approach.
Try multiplication and start with 2.
So you can start with a short form that is roughly that number. If it is 40m digits long then 40 million digits Plus a zero and the number starting with a 1 is an easy immediate approximation.
Running left to right are there any zeros does it matter if there are so that some numbers match up? It all matters from left to right and things carry and numbers change, so you almost need to be God to be able to write a short formula that will give you an answer with 40m random digits.
But, it can be done. How short maybe doesn't matter as long as it is shortish.

Perhaps the best we can do is assign a to mean div 2 and assign b to mean minus 1.

So then our formula when it can divide equally in 2 then that's an a, when it can't that's a b.

aaababaaabaaababaaababaabaa

So then if we right that a3aa3a3aa3aa2a2

We are assuming that if you do 3 div 2 in a row you will need to do the minus 1 according to our shorter notation.
We can search for strings now and say every pattern we see like so a3aa3a3aa3 we will call C.
Now that translates to Caa2a2
Yes of course for the win the Nobel prize for both math and literature.

I can't believe like 5 days ago, that professor was awarded for his proof of the Reimann Hypothesis. 161 years people in large numbers worked on that problem.
I was also alive when someone solved Fermat's Last Theorem proof.
When we all get together and share ideas miracles can happen.

What about this if left mod middle <> 0 then right +1

LMR
12345678987654321
61 and here you see mod <> 0 so the next number becomes 14. but you are screaming through the data writing a3aa2aaa5
as you div 2

What about this if left mod middle <> 0 then right +1

L M R
12 3 4 5 6 7 8 9 8 7 6 5 4 3 2 1
6 1 and here you see mod <> 0 so the next number becomes 14. 3 div 2 and always it will be just one that moves when we div by 2. But you are screaming through the data writing a3aa2aaa5
as you div 2

On Saturday, July 3, 2021 at 3:51:42 PM UTC-7, Kcir wrote:
> What about this if left mod middle <> 0 then right +1
>
> L M R
> 12 3 4 5 6 7 8 9 8 7 6 5 4 3 2 1
> 6 1 and here you see mod <> 0 so the next number becomes 14. 3 div 2 and always it will be just one that moves when we div by 2. But you are screaming through the data writing a3aa2aaa5
> as you div 2

Yes of course by screaming through the data I mean you have to scream through the data every time you write a single a.

On Saturday, July 3, 2021 at 3:55:03 PM UTC-7, Kcir wrote:
> On Saturday, July 3, 2021 at 3:51:42 PM UTC-7, Kcir wrote:
> > What about this if left mod middle <> 0 then right +1
> >
> > L M R
> > 12 3 4 5 6 7 8 9 8 7 6 5 4 3 2 1
> > 6 1 and here you see mod <> 0 so the next number becomes 14. 3 div 2 and always it will be just one that moves when we div by 2. But you are screaming through the data writing a3aa2aaa5
> > as you div 2
> Yes of course by screaming through the data I mean you have to scream through the data every time you write a single a.

Do you see what I am saying?

In order to get an egg, you have to start with a chicken and reverse engineer it to a formula that is an egg.

If you were to try to go the other way, you will never make a chicken.

So a chicken is a designed creature but we can assume the code was developed in stages.

Which came first? The chicken.

On Saturday, July 3, 2021 at 3:59:26 PM UTC-7, Kcir wrote:
> On Saturday, July 3, 2021 at 3:55:03 PM UTC-7, Kcir wrote:
> > On Saturday, July 3, 2021 at 3:51:42 PM UTC-7, Kcir wrote:
> > > What about this if left mod middle <> 0 then right +1
> > >
> > > L M R
> > > 12 3 4 5 6 7 8 9 8 7 6 5 4 3 2 1
> > > 6 1 and here you see mod <> 0 so the next number becomes 14. 3 div 2 and always it will be just one that moves when we div by 2. But you are screaming through the data writing a3aa2aaa5
> > > as you div 2
> > Yes of course by screaming through the data I mean you have to scream through the data every time you write a single a.
> Do you see what I am saying?
>
> In order to get an egg, you have to start with a chicken and reverse engineer it to a formula that is an egg.
>
> If you were to try to go the other way, you will never make a chicken.
>
> So a chicken is a designed creature but we can assume the code was developed in stages.
>
> Which came first? The chicken.

Yes for the win. Nobel prize for physics for creating a formula for a chicken.

I have this great idea for a viral cooking show and if you have nothing to do and are a good actor try it.

So I saw this guy a serious young dude telling people how to speed up their internet by taping batteries and magnets onto their rs-232 cable and it was hilarious.

So you do your serious fun positive 'kooking' show with nice hair and big smile and good voice and you are rubbing a chicken egg onto the pork as if that is going to make a difference and spanking your chicken just so with the right implement and you know doing all these nonsensical things to cook an amazing dinner when it comes out of the oven. Which of course was cooked some other way.

Steal it, make money in youtube.

On 7/3/2021 2:06 PM, Kcir wrote:
> For the win
>
> 1234567898765432123456789
>
> That's a bitch of a number to divide in your head into 1 million quadrillion or something.
>
> And if we intend to take numbers with 40 million digits and divide them into numbers with 40 million and 3 digits.
>
> So do this and see how fast and easy it is so you can do this in your head no seriously in your frickin head.
> notice it is an odd number so we will use a formula and when we are done, our little algebra formula is going to result in that large number in all it's glory so that to send and entire 40mb program through a network, you will go oh that here you go.
> a*b=c+d=e.
> WTF???
> Easy as pie first remove one so it is an even number.
>
> minus 1
> 1234567898765432123456788
> div2 do that in your head you are a genius easy to do.
> see? Now keep doing it and doing your minus 1 and list your operations then what do you have?
>
> think about this. How may of those div 2 can you group into a div 6 or a div 8?
> then your remainder.
> You have to write a computer program since no other way exists to deal with very large numbers yet, but people have written programs but we can make our own and maybe improve on them.
> Like I know by looking at that number the first 4 digits that if I want to divide that into 40mb 1 and 40m zeroes the first 4 digits are the most important. The rest aren't going to do much if the number you divide into has 3 more zeros on the end of it. Which means your answer is going to have 3 or 4 digits.
> And then one hell of a lot of decimal places.
> 81.02
> So we multiply that by 81.02 to see what we get.
> Our calculator in Windows can't use a number that large as above it only got to 2 7 digits short but those aren't important right now.
> 1.000246911579753e+17
>
> So with 81.02 we managed to gt 3 clear digits. We got rid of the large numbers and our remainder is still a gazillion digits long.
> Our program could try to eliminate more digits sequentially. But I am thinking the minus one div 2 formula is going to shrink that number substantially so yeah how many times would you have to multiply a number by 2 to get close? Factors or two.
>
> So you start your computer rolling and you say compare the result to this large number but that is going to take too long.
> So the way to approach it is to use maybe 4 digits at a time on the left and work with remainders as separate operations in a chain reaction formula.
>
>
>

I guess you can get a continued fraction by treating it as:

0.1234567898765432123456789

On Saturday, July 3, 2021 at 4:13:38 PM UTC-7, Chris M. Thomasson wrote:
> On 7/3/2021 2:06 PM, Kcir wrote:
> > For the win
> >
> > 1234567898765432123456789
> >
> > That's a bitch of a number to divide in your head into 1 million quadrillion or something.
> >
> > And if we intend to take numbers with 40 million digits and divide them into numbers with 40 million and 3 digits.
> >
> > So do this and see how fast and easy it is so you can do this in your head no seriously in your frickin head.
> > notice it is an odd number so we will use a formula and when we are done, our little algebra formula is going to result in that large number in all it's glory so that to send and entire 40mb program through a network, you will go oh that here you go.
> > a*b=c+d=e.
> > WTF???
> > Easy as pie first remove one so it is an even number.
> >
> > minus 1
> > 1234567898765432123456788
> > div2 do that in your head you are a genius easy to do.
> > see? Now keep doing it and doing your minus 1 and list your operations then what do you have?
> >
> > think about this. How may of those div 2 can you group into a div 6 or a div 8?
> > then your remainder.
> > You have to write a computer program since no other way exists to deal with very large numbers yet, but people have written programs but we can make our own and maybe improve on them.
> > Like I know by looking at that number the first 4 digits that if I want to divide that into 40mb 1 and 40m zeroes the first 4 digits are the most important. The rest aren't going to do much if the number you divide into has 3 more zeros on the end of it. Which means your answer is going to have 3 or 4 digits.
> > And then one hell of a lot of decimal places.
> > 81.02
> > So we multiply that by 81.02 to see what we get.
> > Our calculator in Windows can't use a number that large as above it only got to 2 7 digits short but those aren't important right now.
> > 1.000246911579753e+17
> >
> > So with 81.02 we managed to gt 3 clear digits. We got rid of the large numbers and our remainder is still a gazillion digits long.
> > Our program could try to eliminate more digits sequentially. But I am thinking the minus one div 2 formula is going to shrink that number substantially so yeah how many times would you have to multiply a number by 2 to get close? Factors or two.
> >
> > So you start your computer rolling and you say compare the result to this large number but that is going to take too long.
> > So the way to approach it is to use maybe 4 digits at a time on the left and work with remainders as separate operations in a chain reaction formula.
> >
> >
> >
> I guess you can get a continued fraction by treating it as:
>
> 0.1234567898765432123456789

Well done. So we have one entry for our lookup table.
A few more and we have it.

So you don;t want to have your scramble formula on disk instead just take a corner of the person's image and use that to scramble the photo so that the hacker does not have access to the formula you used to scramble the image key.

Anyway I have written a program now that can div 2 a large number and drop an 'a' every time it goes through with an even result and a b each time the number is not divisible by 2 so you need to remove a 1.

So it is using a rich edit to hold the numbers. RTF text file program in windows. So however many digits one of those can hold
that is the size of the number it can divide by 2.
Quite quickly.
I will take some screen shots when I am finished testing it.

Ok some screen shots to illustrate a point.
So a large number in the top box.

https://ibb.co/whcj6PN
So you then div it by 2
https://ibb.co/GtSxgzH

See how many digits it has dropped in one operation and it has dropped an a in the middle box.

https://ibb.co/G5J2kkx
Here Re is hit to replace the number in the top box with the result in the bottom box.
This is being done manually now so I can look for patterns and check things as I go but you can easily automate
that process and let it shrink that number using powers of 2 and minus one.
So here I am using ideal conditions, a number that is 1 and all zeroes.
https://ibb.co/wrNkr7P
after the second division and drops an a because it is an even number and can be equally divided by 2.

https://ibb.co/pzJZcLL
So after 4 div 2 operations the number is reduced dramatically and 4 a's are there.
So to reverse the process we take the bottom number and apply the number of a's to multiply the sum by two.

So then when it is not a number that is 1 and zeroes then it drops a list of aaabaaabababaaababaabbbaab
similar to that. So then what you would need to do is to look for a pattern that repeats by comparing
a short string with the full text to find those instances of the long string.
But if you attach a symbol to it and it repeats then you stand to benefit.

if it is a repeat of aaabaaabaaabababaaaab that's a lot of digits to symbolize with one C.
Now every time it repeats and you substitute a C, you gain in reduced size of file.
Now this would be like if you had a zip file and it was compressed already so what you convert it to a's and b's and then compress
it more.
Perhaps substantially more. This is still theory.

So initially in your lookup table here you need to make a copy of the string that you are calling C. So one instance of it
is in the file since you need to refer to it so only if you have at least two instances might it be worth having it
in the lookup table.
So this is just some preliminary work to make a tool to experiment with this concept.
The work will continue and I will expand on its abilities.
It can at present divide large numbers by 2.
Multiply large numbers by 2.
Add large numbers by 2.
By large that might be a million digits.

But if it works on 100 digits it will work on 1 million or 40 million of course it is just a matter of scale.

https://ibb.co/4R6fpQg

So this time I used random numbers and had to apply div 2 and minus 1 far more often.

so after 37 repeats which still only takes a second here because the number is small
https://ibb.co/wzFDvr4
And so that string of a's and b's can be shrunk using numbers to substitute a number for an a.

https://ibb.co/k46v4Xw
So then we tag the remaining sum onto the line so that we can decompress it.

But even if the file was previously zipped it will maybe shrink easily in half yet even a RAR file.
Using this method.
So if your limit for the large numbers box was 1 million characters, then that's 1MB lets say so then you will end up with 20 files
that are 1MB and would need to glom them together, and that file would have started out as a 40MB zipped file.
However, if you read from disk write to disk and don't use the boxes there really is no limit to the size of the number other than time itself.

Since how this utility program works is to just work from one side to the other and it can grab a length of string as it needs it.
And work its way through a large file.
So if your large number was 40MB you don't need to break it up into 40 one MB files.

But what it looks like from here is you will have to decide if you want to do 40 times through or just 20 times through and take 75 percent compression or 50 percent compression.
All the same at this point it works. Proof of concept.