On 9/21/21 12:03 AM, olcott wrote:
On 9/20/2021 10:21 PM, Richard Damon wrote:
On 9/20/21 10:25 PM, olcott wrote:
On 9/20/2021 9:12 PM, Richard Damon wrote:
On 9/20/21 8:14 PM, olcott wrote:
On 9/20/2021 7:00 PM, Ben Bacarisse wrote:
olcott <NoOne@NoWhere.com> writes:
On 9/20/2021 5:06 PM, Ben Bacarisse wrote:
olcott <NoOne@NoWhere.com> writes:
On 9/20/2021 5:00 AM, Ben Bacarisse wrote:No. I stated a fact (about TMs) that has no exceptions. Your >>>>>>>>> secret C
olcott <NoOne@NoWhere.com> writes:
The two machines are already fully operational.It's deceptive to call your secret C functions "machines". It >>>>>>>>>>> hints at
H1 is merely a copy of H.
the formality a clarity of Turing machines, but a TM that is a >>>>>>>>>>> copy of
another will have exactly the same transfer function (i.e. it >>>>>>>>>>> will
never
compute a different result).
Unless one of them has a pathological self-reference relationship >>>>>>>>>> with
its input and the other one does not.
code is another matter, of course. It's just the deception of >>>>>>>>> calling
your code a "machine" that I was objecting to. It gives your >>>>>>>>> hidden
code an air of formality that it lacks.
This is easily proven in a way that you are incapable of
understanding.
You can't even write English. Saying "This is easily proven"
following
a quote from me that you are wrong, means you can easily prove what I >>>>>>> said in the quote -- that you are wrong. That is indeed the case, >>>>>>> but
it is unlikely to be what you meant to say.
Your junk functions are not "machines". The terms suggests an
undeserved formality.
void P(u32 x)
{
if (H(x, x))
HERE: goto HERE;
}
The actual correct x86 emulation of the input to H1(P,P) is different >>>>>> than the actual correct x86 emulation of the input to H(P,P).
Which means that your emulator is broken, or H isn't a Computation.
PERIOD.
That would mean that "a computation" cannot possibly determine that it >>>> has been invoked in infinitely recursive simulation, whereas a C
function with a a pair of static local variables can.
Right, it can't
Yep, a C code fragment can easily be a non-computation.
This means that a C function can do something that a TM cannot do thus >>>> making it strictly more powerful than a TM. Since this seems implausible >>>> I estimate that you are simply wrong.
Nope.
The Rule is that there is no COMPUTATION that the C function can do that >>> a Turing Machine can not do. This is the definition of Turing
Competeness and the Turing Equivalence rule.
Yes a C function can determine that it has been called in infinitely
nested simulation only because it is able to maintain static local data
that is not erased between nested simulations.
If a TM cannot maintain static data between nested simulations then a TM
cannot detect when it is within infinitely nested simulations. This
makes the C function strictly more powerful than the TM.
Maybe, but it doesn't mean it can COMPUTE something that a Turing
Machine can, which is the only thing that Computation Theory is
concerned with.
If it isn't a pure mapping of an input to an output, Computation Theory doesn't care about it.
Also, any 'complete' program (or complete fragment) that has a well
defined input, can be expressed as a Computation, and thus a Turing
Machine could do the equivalent of it. The key here is COMPLETE. You
function isn't 'Complete' as exection goes outside of it and then comes
back in.
Exactly the same way that the simulation of the
machine description of a UTM H that simulates
the machine description P the simulates
machine description of a UTM H that simulates
the machine description P the simulates
machine description of a UTM H that simulates
the machine description P the simulates ...
Olcott H can detect when Olcott P is doing this only because Olcott H
has static local data the survives nested simulations.
If a TM cannot have such static local data then Olcott H is strictly
more powerful than Linz H.
Right, if H IS just a UTM, then H^ is non-halting, but then H doesn't
give an answer to the question H(H^,H^), so it can't answer the question.
Once H has the code to abort the simulation loop, and is also still a
Computation, then H^ will no longer be stuck in an infinite recursion as
the H inside it will ALSO do that same abort to keep it out of the loop,
and H when coming up with its answer needs to take that into account to
give the right answer.
The fact that you can write a program that can detect this sort of
recusion doesn't matter to Computation Theory, it is only concerned
about actual Computations,
and a proper Halt Decider on Computation MUST
be a Computation, as the behavior of a Computaton only depends on the Machine/ALgorithm and the Input Data, so ANY decider that changes its
answer based on something outside that CAN'T be right, by definition, it
give two different answers for a question that always has the same
answer, so it MUST be wrong at time.
The key here is that if H isn't a Computation, then the 'machine' H^
isn't either, so Computation Theory doesn't care about what it does.
The Halting Problem of Computation Theory is STRICTLY about actual Computations.
If your H ACTUALLY is a correct decider for ALL Turing Machines, then by definition it needs to be actually a Computation for ANY Turing Machine
given to it, and thus, it can be shown that there does actually exist a Turing Machine version of it that can take any Turing Machine as an
input. Since this Turing Machine version IS actually a Computation, we
can use the Linz ^ trick on it showing that it gets this case wrong.
The only way we can't do this is if your H isn't a computation for some
P(I) so that there isn't a Turing Machine equivalent for it, but then
there are some conditions under which H calls P(I) both Halting and Non-Halting, so there are some conditions where it gives the wrong
answer, so it isn't the Universal Halt Decider that COmputation Theory
is Looking for.
Again, note that if Olcott-H is NOT a strict computation when given an
actual Turing Machine/Input (or equivalent), then BY DEFINTION it must
be wrong some of the time, as to be a non-computation says that there IS
some condition where for an actual computation is predicts both Halting
and Non-Halting for the exact same computation, and thus one of the
answers MUST be wrong.
Sysop: | Keyop |
---|---|
Location: | Huddersfield, West Yorkshire, UK |
Users: | 366 |
Nodes: | 16 (2 / 14) |
Uptime: | 03:50:30 |
Calls: | 7,812 |
Files: | 12,924 |
Messages: | 5,749,465 |