That confirms it, you don`t have a clue about the terms of this debate
You realize that one of the things I study is cryptology, yes?
Randomness is not an easy thing to talk about.
At any rate, I keep inviting you to find where I actually demand there must be randomness (I don't, beyond pointing out that there are events in the universe whose resolution has no correlation to other events which happen).
As it is, I've discussed this again and again, because YOU are the one who keeps bringing it up!
I've presented a compatibilist choice, an event wherein an agent with many alternatives presented to it, based on proclivity, reduces the set of alternatives to a subset. Really we're just naming the objects in the set "alternatives", because we are discussing a selection of the set, a "choice".
In a software example, an example that produces a machine language rendition of such a structure:
Code:
int proclivity;
int A = 5;
Int B = -5;
.
.
.
int Fn(int var)
{
static int A = 5;
static int B = -5;
if ((A+1)< A)
A=5;
if ((B-1) > B)
B=-5;
if (var < proclivity)
return A++;
else if (var >= proclivity)
return B--;
}
This is a function. A human mind could contain this function. My human mind does contain a slowly functioning version of this function.
This creates a structure that, for argument sake, does not get to decide upon its own proclivity on whether to return A or B (whether it returns a positive or negative number). It does, however, self-regulate the A and B it returns when it does.
It creates a
private A and B
inaccessible to other functions (an aspect of "itself"). It regulates those aspects of "self", even if it does not regulate proclivity (which from the perspective of the function may even be accessed as a constant).
Would you disagree that this function CAN return a positive or negative number?
Would you disagree that this function cannot possibly return 0?
This function is not even restricted to a single possible return for a given var.
At best the reader can say, dependent on the state and number of calls, what it would return if called with a value.
It did not need to write its own machine code to have the function it does. It does not need to decide it's own proclivities to be structure which decides based on those proclivities.
It is a choice function, because it is a function that takes an input (var), and uses that to render a subset (the return value) from a set ({A, B}).
Now, the compatibilist would say "well, given this model (the text) of this system (the machine code), I can design a function that will, with a single execution, render 5,-5."
Assuming 16 bit integers in two's compliment...
Assuming that an
unknown and
unknowable number of calls to Fn have occurred, what is the greatest number of calls required to produce this output?
What is the greatest number of calls to reach N,-N?
N,M?
From a previous solution what is the function that will produce an accurate count of the number of calls to transition from N,M to J,K?
What can be said about the unknown and unknowable number of calls made to Fn previously, as a function of the return values?
How do these change when the proclivity is not accessible to read?
Does being unable to read the proclivity but being able to write blindly to it change this in any way?
How about for n-bit integers in two's compliment?for n*b width signed modulo counters?
To answer any one of these questions which describe objective facts about all things which implement this function one must accept the idea of "may" and "if". One must accept that certain entailments can be calculated on without actually doing a direct entailment, accept that representation may occur.
I can make an object in the universe that behaves this way, and know how it will behave before it ever does any behaving.
I can have a function which is set up to call Fn some number of times, sleep on that thread, release the user of Fn, and have the thread wake just in time to observe the log output of the system hitting an overflow and going to 5,-5 on the other thread, and then go to sleep again without actually checking whether it "caught" the event.
I could have a function that observes memory for that event of the overflow to locate the addresses of A and B and violate the privacy of Fn's static values, and so violate the "free will" of Fn". Depending on security of architecture, the memory may have additional fields which protect the address of A and B from writes off of a program counter other than the writes done by Fn, and forbids writes at all to Fn's code segment. In this way I can make undue influence on Fn's will possible or impossible, depending on implementation.
But I can only even think about these things when I accept that wills can be free or constrained, that choices can be made, and that functions can be represented.
But the point is, this requires deterministic function to be, well... Deterministic! It is exactly determinism that makes simulation and thus prediction using simulations of futures which "may" happen* "if prerequisites to that future are met."
One must accept that fantasy is useful in this way before they can even think about a function that can fantasize about the time it takes another function to run, and be right about it's predictions, for example.
