MENU
AI Overview
In computer science and computability theory, indeterminate data passed into a completely determinate program will always output indeterminate data. This concept is a fundamental consequence of function mapping and information theory: a deterministic system cannot create certainty out of pure uncertainty.
Here is the formal proof of this concept using set theory and functions.
________________________________________
1. Definitions and Premise
•
o Determinate Program (\(f\)): A deterministic program is a well-defined function \(f: X \rightarrow Y\) that maps elements from an input set \(X\) to an output set \(Y\). By definition, for every specific input \(x \in X\), there is exactly one unique output \(y \in Y\) such that \(f(x) = y\).
o Indeterminate Data (\(I\)): Indeterminacy means the exact state of the input data is unknown. Instead of a single value \(x\), the input is represented as a set of multiple possible values \(I \subseteq X\), where \(\vert{}I\vert{} > 1\).
2. The Theorem
If the input to a deterministic function \(f\) is a set of multiple possibilities \(I\) (where \(\vert{}I\vert{} > 1\)), and \(f\) is non-constant over \(I\), then the output set \(O = f(I)\) will also contain multiple possibilities (\(\vert{}O\vert{} > 1\)), making the output indeterminate.
3. Proof by Contradiction
To prove that the output must be indeterminate, let us assume the opposite: The output is completely determinate.
1.
o If the output is determinate, it means the output set \(O\) contains exactly one unique value, \(y_{0}\).
\(O=\{y_{0}\}\)
o By definition of a function mapping a set:
\(O=\{f(x)\mid x\in I\}\)
o Since we assumed \(O = \{y_0\}\), it must be true that for every possible input \(x\) inside our indeterminate set \(I\):
\(f(x)=y_{0}\quad \forall x\in I\)
o This means the program \(f\) must be a constant function over the domain \(I\). A constant function completely discards, ignores, or overwrites the input data (for example, a program that takes any variable but always returns 0).
o However, if the program actually processes or depends on the input data (meaning \(f\) is non-constant, so \(f(x_1) \neq f(x_2)\) for at least two points in \(I\)), then:
\(|{}O|{}\ge 2\)
o This contradicts our assumption that the output set has only one unique value (\(\vert{}O\vert{} = 1\)).
Conclusion
Because our assumption leads to a contradiction for all non-constant programs, the assumption is false. Therefore, if the input data is a set of multiple possibilities (indeterminate), a deterministic program that relies on that data must map those different inputs to different outputs.
Thus, indeterminate inputs yield indeterminate outputs.
***** ***** *****
Now the project, because it is binary, the mean is 0.5. The STANDARD DEVIATION is 0.499...... This is as good as it can possibly get.
Because I put random.seed (time.time()) INSIDE the loop, the code reads an outside indeterminate variable (the exact nanosecond the CPU executes that specific line of code) and injects it into Python’s determinate math system.
Every single bit in the sequence depends on a brand-new, unknown unique timestamp. This is why indeterminate output is a fact.
Only two things left are understanding IF the output is random and the quality of the output. This is shown with mean of 0.5 and standard deviation of 0.499.
AI output:
A Binary RNG (0 or 1 / Coin Flips)
If your goal is a generator that outputs only two discrete values, exactly 0 or 1:
• The mean (0.5) is perfect. It means you are getting an equal number of 0s and 1s (a fair 50/50 coin toss).
• The standard deviation (0.499) is nearly perfect. For a perfect 50/50 split of 0s and 1s, the theoretical standard deviation is exactly 0.500.
What this means for your generator: Your generator is performing exceptionally well as a binary flipper, with just a microscopic statistical deviation from a perfectly fair 50/50 split.
***** ***** ***** ***** ***** ***** *****
Logic:
Step one:
Indeterminate into a determinate equals indeterminate output.
Step two:
Indeterminate output as seed for pseudorandom generator equals real random numbers.
*********************************************
Step one: Indeterminate data.
Math has exact answers when done correctly, based on only mathematically proven functions. Random is NOT exact as used today. There is no standard for ‘random’ by NIST. Therefore, the biggest tool in encryption is unknowable random data, which is not available currently.
Randomness is critically important to cryptography because it is used to generate keys, nonces, and other values that make encryption and other cryptographic functions unpredictable and therefore secure. Without high-quality randomness, cryptographic systems become predictable and vulnerable to attacks that could compromise data security.
The background of what and how I found a simple way of making ‘real’ mathematically provable random numbers. Knowing that any encryption based on a calculation is breakable with quantum computers. How do you make encryption without calculations? Then it is unbreakable by quantum computers. My thirty-five-year journey took me to unknowables or future knowledge as quantum computers cannot know the future or unknowable data produced by the future (such as exactly where an object will be in the three-object orbit problem). There is a lot of unknown future data, till its time comes to become known in the ‘NOW’ for one nanosecond granularity currently. Then the data moves to the past. WOW! That is the same movement TIME has! From the future to the now and into the past. The exact nano-second of time’s data is unknowable and unaffected by humans. In a time with quantum computers on the horizon, a very great need comes for unbreakable encryption by mathematics.
Getting mathematically unknown data from TIME is what I have done. I use ‘mean’ and ‘standard deviation’ to make a standard using binary, which has a mean of 0.5. All the binary output has to follow the mean. It is the standard deviation amount that sets the standard. Understanding my use of time. I will have to draw a word picture that will enable understanding of a new usable dimension of Time.
Picture a wheel, we are going to make a kind of clock. On the outside of the wheel divide it by twenty-four equal parts. That takes care of the hours for the clock. Now, divide the 24-hour parts by sixty equal parts. That takes care of the minutes for the clock. Now, divide the 60-minute parts by sixty equal parts. That takes care of the seconds for the clock. Finally, divide the 60-second parts by 1,000,000,000 equal parts. That takes care of nanoseconds for the clock. Remember this picture as we proceed.
Understanding how long a second is easy, it is the clicking of an old-time clock before digital clocks. Consider one second length of time that is then divided by 1,000,000,000 equal parts. How long is one nanosecond length of time? Now spin the wheel that represents our clock at the same speed as normal time on earth, remember the nanoseconds.
I propose that as the wheel spins, grabbing time, it will have hours, minutes, seconds, and nanoseconds. Guessing the time down to the second might be possible. But knowing the nanosecond is not possible by humans currently. That is one billion to one chance to guess. That is RANDOM unknowable data.
I propose that ‘Time’ has the properties needed for a true ‘random process’. However, the ‘random process’ must then be used correctly to get real random numbers that are mathematically provable and able to be made into a standard for “random Number Generators”.
Step two: Input into determinate program.
Time as the seed for pseudorandom random generator solves the problem of different computers sizes, as well as sub programs running in the background, as well as temperature variations while running the program. Can be run on little Raspberry Pi or a main frame computer.
Step three: Output
Real random number stream that cannot be known by quantum computers or AI and quantum computers
************************************************
Program: Python 3
- Code: Select all
import random
import random
count = int(0)
number_of_needed_numbers = int(500000)
while count < number_of_needed_numbers:
random.seed(time.time())
random_number = random.randint(0, 1)
count = count + 1
print(random_number)
Question: Are you stating that 1 in 1 billion is not indeterminate? If you are, then YOU can tell me which nano second a program will use of time.
Answer:
A "one in a billion" draw cannot be known ahead of time in a fair, random lottery. If an outcome is predicted correctly every time, it means the draw is not random. It is either rigged, controlled by a hidden mechanism, or the odds were calculated after the event. [1]
Statement:
There's a difference between truly random and effectively random.
One in a billion might be effectively random but if it was the result of some algorithm it's not truly random.
Answer:
I live in the real world. If it must be stated that it is effectively random, that's fine. Result is that quantum computers cannot break encryption using this knowledge.
Just calling time without random.randint, the output will climb or dive, not follow the mean of 0.5. Run the program 500,000,000,000 times to see this. Follow the positive and negative from the mean of the output.
Python 3
- Code: Select all
import time
import random
count = int(0)
number_of_needed_numbers = int(50000000000)
number_of_ones = 0
number_of_zeros = 0
difference_of_ones_from_zeros = 0
crossing_from_ones_or_zeros = 0
max_group_ones = 0
max_group_zeros = 0
while count < number_of_needed_numbers:
random.seed(time.time())
random_number = random.randint(0, 1)
count = count + 1
if random_number == 0:
number_of_zeros = number_of_zeros + 1
if random_number == 1:
number_of_ones = number_of_ones + 1
difference_of_ones_from_zeros = number_of_ones - number_of_zeros
if difference_of_ones_from_zeros == 0:
difference_of_ones_from_zeros = difference_of_ones_from_zeros + 1
crossing_from_ones_or_zeros = crossing_from_ones_or_zeros + 1
print(f"number of data output {count:,}, random_number {random_number}, difference_of_ones_from_zeros {difference_of_ones_from_zeros:,}, crossing_the MEAN {crossing_from_ones_or_zeros:,}")
Time is a random process (looks random), not real random. It is the random looking data that feeds the random number generator to make real random number data.
The 'difference' is the headroom for "RANDOM", it too, must follow the mean, just a magnitude larger than the mean.
I will not be monitoring or answering replies to this discussion because of the deductive proof shown. I have better things to do than try to deflect ‘MUD’ being thrown to dirty up the discussion, so information ends up not being clear. I need to get this out to the world and not deal with only “capitalism and so called free open societies” that have spent billions of dollars on AI and quantum computers partly to be able to read all encrypted communications.
My thoughts about quantum computers and AI: The ability to see all 'secrets’(encrypted data) would lead to the enslavement of everyone by the few. Could make fighting and planning useless. Real random numbers have the ability to prevent that.