On 5/24/2023 1:10 PM, Richard Damon wrote:
On 5/24/23 2:02 PM, olcott wrote:You keep disagreeing with the easily verified fact that D correctly
On 5/24/2023 12:00 PM, Richard Damon wrote:
On 5/24/23 12:09 PM, olcott wrote:
On 5/24/2023 10:57 AM, Richard Damon wrote:
On 5/24/23 11:47 AM, olcott wrote:
On 5/23/2023 7:38 PM, Richard Damon wrote:
On 5/23/23 9:50 AM, olcott wrote:You keep insisting on staying out-of-sync by one recursive
On 5/23/2023 6:44 AM, Richard Damon wrote:
On 5/22/23 11:31 PM, olcott wrote:
On 5/22/2023 10:12 PM, Richard Damon wrote:
On 5/22/23 10:49 PM, olcott wrote:
On 5/22/2023 9:27 PM, olcott wrote:
On 5/22/2023 9:02 PM, Richard Damon wrote:
On 5/22/23 9:33 PM, olcott wrote:
On 5/22/2023 6:22 PM, Richard Damon wrote:
On 5/22/23 10:22 AM, olcott wrote:
On 5/21/2023 2:02 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 5/21/23 2:50 PM, olcott wrote:
Yet any theory of computation computer scientist knows >>>>>>>>>>>>>>>>>> that a simulationOn 5/21/2023 1:39 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 5/21/23 2:12 PM, olcott wrote:
On 5/21/2023 11:54 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/21/23 10:16 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 6:52 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 5:29 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 4:24 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 5:10 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 3:48 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 4:33 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 2:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 3:29 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 1:54 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 2:46 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 1:15 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:So?
It makes no error. As you already admitted D >>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly terminate normally thus its >>>>>>>>>>>>>>>>>>>>>>>>>>>> isomorphism of ⟨Ĥ⟩ correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by embedded_H cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally.*Yet only at the point where it aborts its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation*When a simulating halt decider correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates N steps of its input >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it derives the exact same N steps that a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pure UTM would derive because >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it is itself a UTM with extra features. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>On 5/20/23 1:09 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 11:10 AM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 11:24 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 10:19 AM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 10:54 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 8:49 AM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 12:00 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 10:27 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 11:00 PM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 9:51 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 8:56 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Wrong Question! >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> In other words the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question is over you head. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It took me many years to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recognize this same >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dodge by Ben. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, it is the WRONG >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question once you try to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> apply the answer to the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem, which >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you do. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So the software >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> engineering really is over >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your head? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I see, so like Ben you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have never actually >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> written any code. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But you aren't talking >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about Software Engineering >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unless you are lying about >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this applying to the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem described >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by Linz, since that is the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Computability Theory. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Of course, the likely >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> explanation is that you are >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just ignorant of what you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are talking about, so you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> don't understand the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> diference. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ben kept masking his >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> coding incompetence this way. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It never occurred to me >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you have never >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> written any code. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have possibly written >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> more WORKING code than you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I don't believe you. Your >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inability to answer an >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> straight forward >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> software engineering >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question seems to prove >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> otherwise. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> What software engineering >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The answer to that question is NO, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Finally you admit an easily >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> verified fact. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but that is because H doesn't, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and can never do an accurarte >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation per the definition >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of a UTM. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the simulation by a UTM would >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be wrong then you would have to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be able >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to point out the mistake in the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of D by H, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You have already agreed that it does >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulate the first N steps >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly. It is just as obvious >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the behavior pattern of N steps of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ correctly simulated by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H cannot possibly terminate >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normally >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> even if the value of N is ∞. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>No, the simulation by a ACTUAL >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM will reach a final state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>I don't know why you say this when >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you already know that ⟨Ĥ⟩ correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by embedded_H cannot >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Because embedded_H doesn't actually >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "Correctly Simulate" its input by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the definintion aquired by your >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mentioning of a UTM. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
But N steps in not ALL steps as >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> required by the actual definition of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a UTM.
Actually N steps is the exact >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a UTM for those N steps. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Just like with the H/D example after N >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps we can see that neither >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D correctly simulated by H nor ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated by embedded_H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Nope, UTMs have no concept of only >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doing a partial simulation. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Just like a racing car is a street legal >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> care with extra features that makes it no >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> longer street legal. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The fact that H aborts its simulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> part way means it is no longer a UTM >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Right, but that affect the behavior of ALL >>>>>>>>>>>>>>>>>>>>>>>>>>>>> copies of it, since they all act the same. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Do you think you are immortal because you >>>>>>>>>>>>>>>>>>>>>>>>>>>>> haven't died yet, and that everyone is >>>>>>>>>>>>>>>>>>>>>>>>>>>>> immortal until the point in time they die? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Since it just proves it isn't a UTM, it >>>>>>>>>>>>>>>>>>>>>>>>>>>>> can't assume that the copy it is simulating >>>>>>>>>>>>>>>>>>>>>>>>>>>>> is, it needs to account for that behavior. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The fact that the DESIGN logic to do this >>>>>>>>>>>>>>>>>>>>>>>>>>>>> goes into an infinite loop, doesn't mean >>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the program itself does. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Since H aborts its simulation and returns >>>>>>>>>>>>>>>>>>>>>>>>>>>>> 0, its input will see its copy do exactly >>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same thing and thus will Halt, making >>>>>>>>>>>>>>>>>>>>>>>>>>>>> the answer wrong.
Since H isn't a UTM, since if fails to meet >>>>>>>>>>>>>>>>>>>>>>>>>>>>> the defintion, the fact that it can't reach >>>>>>>>>>>>>>>>>>>>>>>>>>>>> a final state is irrelevent, as is any >>>>>>>>>>>>>>>>>>>>>>>>>>>>> definiton of "Correct Simulation" that >>>>>>>>>>>>>>>>>>>>>>>>>>>>> differs from what a UTM does. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
UTM(D,D) Halts, therefore the CORRECT >>>>>>>>>>>>>>>>>>>>>>>>>>>>> SIMULATION (by a UTM which is what is >>>>>>>>>>>>>>>>>>>>>>>>>>>>> allowed to replace the actual behavior of >>>>>>>>>>>>>>>>>>>>>>>>>>>>> the machine) Halts, and thus the CORRECT >>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer is Halting.
You are just showing that you have fallen >>>>>>>>>>>>>>>>>>>>>>>>>>>>> for your own Strawman Deception that got >>>>>>>>>>>>>>>>>>>>>>>>>>>>> you to use the wrong criteria. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
At this point where it aborts its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation we can see that it must >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do this to prevent its own infinite >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution, thus conclusively proving >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it correctly determined that its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
How much longer are you going to play the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fool and deny this? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
No, it does so because it has been >>>>>>>>>>>>>>>>>>>>>>>>>>>>> programmed to do so, and thus ALL copies of >>>>>>>>>>>>>>>>>>>>>>>>>>>>> it will do so.
It makes the error assuming that the copy >>>>>>>>>>>>>>>>>>>>>>>>>>>>> it is simulating will do something >>>>>>>>>>>>>>>>>>>>>>>>>>>>> different than it does. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
Are you going to keep playing the fool on this? >>>>>>>>>>>>>>>>>>>>>>>>>>>>
Except that you are answering the wrong >>>>>>>>>>>>>>>>>>>>>>>>>>> question.
In other words you want to keep playing the >>>>>>>>>>>>>>>>>>>>>>>>>> fool and dodging the actual question that I am >>>>>>>>>>>>>>>>>>>>>>>>>> actually asking.
No, you are showing yourself to be the fool by >>>>>>>>>>>>>>>>>>>>>>>>> not understand your own stupidity. >>>>>>>>>>>>>>>>>>>>>>>>>
So you agreed that D correctly simulated H >>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly terminate
normally and the exact same thing goes for ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated by
embedded_H.
No, I am saying that H can not correctly >>>>>>>>>>>>>>>>>>>>>>>>> simulate the input H and give an answer. If H >>>>>>>>>>>>>>>>>>>>>>>>> DOES try to correctly simulate its input, then >>>>>>>>>>>>>>>>>>>>>>>>> it can never giv an answer.
Since you already acknowledged that D correctly >>>>>>>>>>>>>>>>>>>>>>>> simulated by H can never
terminate normally and you did not need an >>>>>>>>>>>>>>>>>>>>>>>> infinite amount of time to
determine this then the isomorphic ⟨Ĥ⟩ correctly >>>>>>>>>>>>>>>>>>>>>>>> simulated by embedded_H
can also be determined to never terminate >>>>>>>>>>>>>>>>>>>>>>>> normally and this
determination can be made in a finite amount of >>>>>>>>>>>>>>>>>>>>>>>> time.
In both cases this can be correctly determined >>>>>>>>>>>>>>>>>>>>>>>> after N steps of
simulation thus no need for the infinite >>>>>>>>>>>>>>>>>>>>>>>> simulation that you keep
insisting is necessary.
You keep on LYING about what I said. Any H that >>>>>>>>>>>>>>>>>>>>>>> gives an answer can not "Correctly Simulate" this >>>>>>>>>>>>>>>>>>>>>>> input per the definitions that allow simulation >>>>>>>>>>>>>>>>>>>>>>> to replace the behavior of the actual machine. >>>>>>>>>>>>>>>>>>>>>>>
Since you already acknowledged that D correctly >>>>>>>>>>>>>>>>>>>>>> simulated by H cannot
possibly terminate normally (hence [key >>>>>>>>>>>>>>>>>>>>>> agreement]) and the H/D pair is
isomorphic to the embedded_H / ⟨Ĥ⟩ pair you >>>>>>>>>>>>>>>>>>>>>> contradict yourself.
D(D) / Ĥ (Ĥ) still halt since H returns >>>>>>>>>>>>>>>>>>>>> non-halting, thus that answer is wrong for the >>>>>>>>>>>>>>>>>>>>> Halting Problem.
It only seems wrong because all of the textbooks >>>>>>>>>>>>>>>>>>>> reject simulating
halt deciders out-of-hand without review incorrectly >>>>>>>>>>>>>>>>>>>> assuming that
simulation cannot possibly be used as the basis of a >>>>>>>>>>>>>>>>>>>> halt decider:
No, it is wrong because the question asks about the >>>>>>>>>>>>>>>>>>> actual machine, and that halts, so the right answer >>>>>>>>>>>>>>>>>>> is HALTING.
of N steps by a UTM does provide that actual behavior >>>>>>>>>>>>>>>>>> of the actual
input to this UTM.
Nope, only if the machine reaches a final state in that >>>>>>>>>>>>>>>>> Nth Step.
You just don't understand what a UTM is or what it does. >>>>>>>>>>>>>>>>>
They also know that when the input to this UTM is >>>>>>>>>>>>>>>>>> defined to have a
pathological relationship to this UTM that this >>>>>>>>>>>>>>>>>> changes the behavior of
this correctly simulated input.
Nope, a UTM simulation is only correct if it exactly >>>>>>>>>>>>>>>>> matches the FULL b4ehavior of the machine it is looking >>>>>>>>>>>>>>>>> at. That is its DEFINITION.
Yes, do that, so anyone who actually understand the >>>>>>>>>>>>>>>>> theory knows from that start that you are a crackpot. >>>>>>>>>>>>>>>>>
Maybe I should begin my paper with this self-evident >>>>>>>>>>>>>>>>>> truth before
proceeding to the notion of a simulating halt decider. >>>>>>>>>>>>>>>>>
In any case the perfect isomorphism between H/D and >>>>>>>>>>>>>>>>>> embedded_H / ⟨Ĥ⟩
already fully proves this point.
Why, since neither H or embedded_H are actually UTMs, >>>>>>>>>>>>>>>>> and it is establishied that both of them declare their >>>>>>>>>>>>>>>>> input to be non-halting when the machine they are given >>>>>>>>>>>>>>>>> the description of Halt.
*Clearly you are clueless about what the term
isomorphism means*
Both D and ⟨Ĥ⟩ have the exact same form in that both D >>>>>>>>>>>>>>>> and ⟨Ĥ⟩ attempt to
do the opposite of whatever their corresponding halt >>>>>>>>>>>>>>>> decider determines.
Both of them loop when their halt decider returns >>>>>>>>>>>>>>>> {halts} and both halt
when their halt decider returns {non-halting}. Both of >>>>>>>>>>>>>>>> them continue to
call the halt decider in recursive simulation until >>>>>>>>>>>>>>>> their halt decider
stops simulating them.
Right, so since the Halt Decider must have a defined >>>>>>>>>>>>>>> behavior when given them as an input, that defined >>>>>>>>>>>>>>> behavior will always be wrong, because no matter how you >>>>>>>>>>>>>>> define your H, the machines will act the other way. This >>>>>>>>>>>>>>> is what proves that there can't be a decider that gets >>>>>>>>>>>>>>> all input right.
I did not say that precisely enough.
Both of the simulated inputs [WOULD] loop if their >>>>>>>>>>>>>> corresponding halt
decider [WOULD] return {halts} to them and [WOULD] halt >>>>>>>>>>>>>> loop if their
corresponding halt decider [WOULD] return {non-halting} to >>>>>>>>>>>>>> them yet the
actual case is that they remain stuck in recursive >>>>>>>>>>>>>> simulation until
their corresponding halt decider stops simulating them. >>>>>>>>>>>>>>
Thus as you admitted for the H/D pair also applies to the >>>>>>>>>>>>>> embedded_H / ⟨Ĥ⟩ pair. The simulated input cannot possibly >>>>>>>>>>>>>> terminate
normally because it remains stuck in recursive simulation >>>>>>>>>>>>>> until the
simulation is terminated *IN BOTH CASES*
You seem to be acting like the HBO Westworld character >>>>>>>>>>>>> Bernard that was
a robot (AKA host) was almost perfectly a very smart human >>>>>>>>>>>>> except that
his brain was hard-wired to not be able to "see" a specific >>>>>>>>>>>>> door.
Then, once they're inside the dark house where Ford's >>>>>>>>>>>>> robotic family
lives, Theresa asks what's behind one of the doors. "What >>>>>>>>>>>>> door?" Bernard
asks, and that's when you know he's a host as well. The >>>>>>>>>>>>> door is plain as
day, even in the dark, and he's been there before. And yet, >>>>>>>>>>>>> he couldn't
see it.
https://www.forbes.com/sites/erikkain/2016/11/14/one-of-the-biggest-westworld-fan-theories-just-came-true/?sh=5bcd83a38a3e
So, where do Main -> H(D,D) and main -> D(D) -> H(D,D) >>>>>>>>>>>> differ in their execution path?
You claim they differ, so show it.
If you really do know software engineering then you already >>>>>>>>>>> know on the
basis that you already agreed that D simulated by H cannot >>>>>>>>>>> terminate
normally.
Yes, but the question isn't what does the (partial) simulation >>>>>>>>>> by H show, but what does the machine repesented by the input do. >>>>>>>>>>
Since H doesn't simulate all of the behavior of D, its
simulation doesn't directly prove that answer.
When you ask a question that you already know the answer to >>>>>>>>>>> then you are
only playing head games.
Excdpt what the simulation by H does isn't the question that H >>>>>>>>>> is supposed to be answering.
That, or you are claiming that a "Correct Simulation" can >>>>>>>>>>>> differ from the actual machine behavior, despite that going >>>>>>>>>>>> against the definition.
You already admitted that D simulated by H never terminates >>>>>>>>>>> normally.
Thus you knew that H is correct to abort its simulation of D >>>>>>>>>>> to prevent
its own infinite execution.
H is allowed to abort its simulation for any reason its
programmer wants. It still needs to give the right answer to >>>>>>>>>> be correct, and that answer needs to describe the behavior of >>>>>>>>>> directly running the machine given an input.
Since H(D,D) has been said to return 0, we can by simple
inspection, and verify by actually running it, see that D(D) >>>>>>>>>> will Halt, which means that H's answer is just wrong.
It might be a correct POOP decider, but only you seem
interested in your POOP.
The reason that I did this concretely in C is the there is no >>>>>>>>>>> wiggle
room of ambiguity to deny what is actually occurring.
My way results in a halt decider that recognizes the actual
behavior of
the actual input so that it doesn't get stuck in recursive
simulation.
No, becase the ACTUAL BEHAVIOR of the machine in question is
what it does when actually run.
invocation.
Can D correctly simulated by H terminate normally?
Why does that matter?
Since H is being asked about the actual execution of D(D).
*This is factually incorrect*
H is only being asked about the behavior of its input.
Which is DEFINED as the Behavior of the Machine it describes.
H is not being asked about the behavior of a non-input.
So, you think the x86 code of a program isn't a suitable description
of an x86 program?
You already know that a decider computes the mapping
*from its input* to its own accept or reject state.
Right, and the "Input" is a description of a machine it is to decide
the behavior of.
In fact, you CAN define the behavior basd on simulation, as long as
the simulation is of the right sort, that of an UNCONDITION COMPLETE
SIMULATION.
H needs to answer about what your x86 simulator, if put into pure
simulation mode, would do when simulating the input to H.
That is its exact input, just not what it itself would do with it.
That is the difference between accurately simulating an input and
deciding on it. Accurate simulations of a non-halting input take
forever, deciding on it must take finite time.
Thus, H(P,d) needs to decide what UTM(P,d) would do with the exact
same input. Note, D calls H, not the machine simulating it, so
UTM(D,D) would see D(D) calling H(D.D) and what H(D,D) does with
that input.
The behavior of the non-input is the behavior that is one
recursive invocation removed from the behavior of its input.
Nope, You are just proving you don't understand a THING about the
problem
I guess this is why you can't understand how Turing Machine works.
They are defined simply enough you can't twist them.
H uses an x86 emulator to correctly simulate D.
No, it partially simulates the execution path o D.
Since you ar equating simulation to direct execution, the only
meaning of correct includes being COMPLETE.
01 int D(int (*x)())
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
*Execution Trace*
main() calls H(D,D) that simulates D(D) at line 11
*keeps repeating*
simulated D(D) calls simulated H(D,D) that simulates D(D) at line >>>>>>> 03 ...
You keep disagreeing with the easily verified fact that D correctly
simulated by H cannot possibly terminate normally thus conclusively
proving your total lack of any interest in an honest dialogue.
Which is an irrelevent fact, since we aren't asking H about its own
PARTIAL simulation of its input,
simulated by H cannot possibly EVER terminate normally even if the
simulation could be infinite.
This seems to conclusively prove that your software engineering skills
are not very good or you have no intention on participating in any
honest dialogue.
On 5/24/23 2:45 PM, olcott wrote:
On 5/24/2023 1:10 PM, Richard Damon wrote:
On 5/24/23 2:02 PM, olcott wrote:
On 5/24/2023 12:00 PM, Richard Damon wrote:
On 5/24/23 12:09 PM, olcott wrote:
On 5/24/2023 10:57 AM, Richard Damon wrote:
On 5/24/23 11:47 AM, olcott wrote:
On 5/23/2023 7:38 PM, Richard Damon wrote:
On 5/23/23 9:50 AM, olcott wrote:You keep insisting on staying out-of-sync by one recursive
On 5/23/2023 6:44 AM, Richard Damon wrote:
On 5/22/23 11:31 PM, olcott wrote:
On 5/22/2023 10:12 PM, Richard Damon wrote:
On 5/22/23 10:49 PM, olcott wrote:
On 5/22/2023 9:27 PM, olcott wrote:
On 5/22/2023 9:02 PM, Richard Damon wrote:
On 5/22/23 9:33 PM, olcott wrote:
On 5/22/2023 6:22 PM, Richard Damon wrote:
On 5/22/23 10:22 AM, olcott wrote:
On 5/21/2023 2:02 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 5/21/23 2:50 PM, olcott wrote:
Yet any theory of computation computer scientist >>>>>>>>>>>>>>>>>>> knows that a simulationOn 5/21/2023 1:39 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 5/21/23 2:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/21/2023 11:54 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/21/23 10:16 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 6:52 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 5:29 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 4:24 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 5:10 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 3:48 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 4:33 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 2:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 3:29 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 1:54 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 2:46 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 1:15 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
So?Since you already acknowledged that D correctly >>>>>>>>>>>>>>>>>>>>>>>>> simulated by H can neverIt makes no error. As you already admitted >>>>>>>>>>>>>>>>>>>>>>>>>>>>> D correctly simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly terminate normally thus its >>>>>>>>>>>>>>>>>>>>>>>>>>>>> isomorphism of ⟨Ĥ⟩ correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by embedded_H cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally.*Yet only at the point where it aborts >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation*When a simulating halt decider >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulates N steps of its input >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it derives the exact same N steps that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a pure UTM would derive because >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it is itself a UTM with extra features. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>On 5/20/23 1:09 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 11:10 AM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 11:24 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 10:19 AM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 10:54 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 8:49 AM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 12:00 AM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 10:27 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 11:00 PM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 9:51 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 8:56 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Wrong Question! >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> In other words the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question is over you head. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It took me many years >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to recognize this same >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dodge by Ben. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, it is the WRONG >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question once you try to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> apply the answer to the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem, which >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you do. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So the software >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> engineering really is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> over your head? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I see, so like Ben you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have never actually >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> written any code. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But you aren't talking >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about Software Engineering >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unless you are lying about >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this applying to the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem described >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by Linz, since that is the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Computability Theory. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Of course, the likely >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> explanation is that you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are just ignorant of what >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are talking about, so >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you don't understand the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> diference. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ben kept masking his >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> coding incompetence this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> way. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It never occurred to me >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you have never >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> written any code. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have possibly written >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> more WORKING code than you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I don't believe you. Your >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inability to answer an >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> straight forward >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> software engineering >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question seems to prove >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> otherwise. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> What software engineering >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The answer to that question is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> NO, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Finally you admit an easily >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> verified fact. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but that is because H doesn't, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and can never do an accurarte >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation per the definition >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of a UTM. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the simulation by a UTM >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would be wrong then you would >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have to be able >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to point out the mistake in the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of D by H, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, the simulation by a ACTUAL >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM will reach a final state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I don't know why you say this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when you already know that ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by embedded_H cannot >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You have already agreed that it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does simulate the first N steps >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly. It is just as obvious >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the behavior pattern of N >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ correctly simulated by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> even if the value of N is ∞. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Because embedded_H doesn't >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually "Correctly Simulate" its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input by the definintion aquired >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by your mentioning of a UTM. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
But N steps in not ALL steps as >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> required by the actual definition of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a UTM. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Actually N steps is the exact >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a UTM for those N steps. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Just like with the H/D example after >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> N steps we can see that neither >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D correctly simulated by H nor ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated by embedded_H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Nope, UTMs have no concept of only >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doing a partial simulation. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Just like a racing car is a street legal >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> care with extra features that makes it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> no longer street legal. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The fact that H aborts its simulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> part way means it is no longer a UTM >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Right, but that affect the behavior of ALL >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> copies of it, since they all act the same. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Do you think you are immortal because you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> haven't died yet, and that everyone is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> immortal until the point in time they die? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Since it just proves it isn't a UTM, it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can't assume that the copy it is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating is, it needs to account for >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that behavior.
The fact that the DESIGN logic to do this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> goes into an infinite loop, doesn't mean >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the program itself does. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Since H aborts its simulation and returns >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 0, its input will see its copy do exactly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same thing and thus will Halt, making >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the answer wrong.
Since H isn't a UTM, since if fails to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> meet the defintion, the fact that it can't >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach a final state is irrelevent, as is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any definiton of "Correct Simulation" that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> differs from what a UTM does. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
UTM(D,D) Halts, therefore the CORRECT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SIMULATION (by a UTM which is what is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> allowed to replace the actual behavior of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the machine) Halts, and thus the CORRECT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer is Halting. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You are just showing that you have fallen >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for your own Strawman Deception that got >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you to use the wrong criteria. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
At this point where it aborts its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation we can see that it must >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do this to prevent its own infinite >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution, thus conclusively proving >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it correctly determined that its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
How much longer are you going to play the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fool and deny this? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
No, it does so because it has been >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> programmed to do so, and thus ALL copies >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of it will do so.
It makes the error assuming that the copy >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it is simulating will do something >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> different than it does. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Are you going to keep playing the fool on >>>>>>>>>>>>>>>>>>>>>>>>>>>>> this?
Except that you are answering the wrong >>>>>>>>>>>>>>>>>>>>>>>>>>>> question.
In other words you want to keep playing the >>>>>>>>>>>>>>>>>>>>>>>>>>> fool and dodging the actual question that I >>>>>>>>>>>>>>>>>>>>>>>>>>> am actually asking.
No, you are showing yourself to be the fool by >>>>>>>>>>>>>>>>>>>>>>>>>> not understand your own stupidity. >>>>>>>>>>>>>>>>>>>>>>>>>>
So you agreed that D correctly simulated H >>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly terminate >>>>>>>>>>>>>>>>>>>>>>>>>>> normally and the exact same thing goes for >>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ correctly simulated by >>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H.
No, I am saying that H can not correctly >>>>>>>>>>>>>>>>>>>>>>>>>> simulate the input H and give an answer. If H >>>>>>>>>>>>>>>>>>>>>>>>>> DOES try to correctly simulate its input, then >>>>>>>>>>>>>>>>>>>>>>>>>> it can never giv an answer. >>>>>>>>>>>>>>>>>>>>>>>>>
terminate normally and you did not need an >>>>>>>>>>>>>>>>>>>>>>>>> infinite amount of time to
determine this then the isomorphic ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated by embedded_H >>>>>>>>>>>>>>>>>>>>>>>>> can also be determined to never terminate >>>>>>>>>>>>>>>>>>>>>>>>> normally and this
determination can be made in a finite amount of >>>>>>>>>>>>>>>>>>>>>>>>> time.
In both cases this can be correctly determined >>>>>>>>>>>>>>>>>>>>>>>>> after N steps of
simulation thus no need for the infinite >>>>>>>>>>>>>>>>>>>>>>>>> simulation that you keep
insisting is necessary.
You keep on LYING about what I said. Any H that >>>>>>>>>>>>>>>>>>>>>>>> gives an answer can not "Correctly Simulate" >>>>>>>>>>>>>>>>>>>>>>>> this input per the definitions that allow >>>>>>>>>>>>>>>>>>>>>>>> simulation to replace the behavior of the actual >>>>>>>>>>>>>>>>>>>>>>>> machine.
Since you already acknowledged that D correctly >>>>>>>>>>>>>>>>>>>>>>> simulated by H cannot
possibly terminate normally (hence [key >>>>>>>>>>>>>>>>>>>>>>> agreement]) and the H/D pair is
isomorphic to the embedded_H / ⟨Ĥ⟩ pair you >>>>>>>>>>>>>>>>>>>>>>> contradict yourself.
D(D) / Ĥ (Ĥ) still halt since H returns >>>>>>>>>>>>>>>>>>>>>> non-halting, thus that answer is wrong for the >>>>>>>>>>>>>>>>>>>>>> Halting Problem.
It only seems wrong because all of the textbooks >>>>>>>>>>>>>>>>>>>>> reject simulating
halt deciders out-of-hand without review >>>>>>>>>>>>>>>>>>>>> incorrectly assuming that
simulation cannot possibly be used as the basis of >>>>>>>>>>>>>>>>>>>>> a halt decider:
No, it is wrong because the question asks about the >>>>>>>>>>>>>>>>>>>> actual machine, and that halts, so the right answer >>>>>>>>>>>>>>>>>>>> is HALTING.
of N steps by a UTM does provide that actual behavior >>>>>>>>>>>>>>>>>>> of the actual
input to this UTM.
Nope, only if the machine reaches a final state in >>>>>>>>>>>>>>>>>> that Nth Step.
You just don't understand what a UTM is or what it does. >>>>>>>>>>>>>>>>>>
They also know that when the input to this UTM is >>>>>>>>>>>>>>>>>>> defined to have a
pathological relationship to this UTM that this >>>>>>>>>>>>>>>>>>> changes the behavior of
this correctly simulated input.
Nope, a UTM simulation is only correct if it exactly >>>>>>>>>>>>>>>>>> matches the FULL b4ehavior of the machine it is >>>>>>>>>>>>>>>>>> looking at. That is its DEFINITION.
Yes, do that, so anyone who actually understand the >>>>>>>>>>>>>>>>>> theory knows from that start that you are a crackpot. >>>>>>>>>>>>>>>>>>
Maybe I should begin my paper with this self-evident >>>>>>>>>>>>>>>>>>> truth before
proceeding to the notion of a simulating halt decider. >>>>>>>>>>>>>>>>>>
In any case the perfect isomorphism between H/D and >>>>>>>>>>>>>>>>>>> embedded_H / ⟨Ĥ⟩
already fully proves this point.
Why, since neither H or embedded_H are actually UTMs, >>>>>>>>>>>>>>>>>> and it is establishied that both of them declare their >>>>>>>>>>>>>>>>>> input to be non-halting when the machine they are >>>>>>>>>>>>>>>>>> given the description of Halt.
*Clearly you are clueless about what the term >>>>>>>>>>>>>>>>> isomorphism means*
Both D and ⟨Ĥ⟩ have the exact same form in that both D >>>>>>>>>>>>>>>>> and ⟨Ĥ⟩ attempt to
do the opposite of whatever their corresponding halt >>>>>>>>>>>>>>>>> decider determines.
Both of them loop when their halt decider returns >>>>>>>>>>>>>>>>> {halts} and both halt
when their halt decider returns {non-halting}. Both of >>>>>>>>>>>>>>>>> them continue to
call the halt decider in recursive simulation until >>>>>>>>>>>>>>>>> their halt decider
stops simulating them.
Right, so since the Halt Decider must have a defined >>>>>>>>>>>>>>>> behavior when given them as an input, that defined >>>>>>>>>>>>>>>> behavior will always be wrong, because no matter how you >>>>>>>>>>>>>>>> define your H, the machines will act the other way. This >>>>>>>>>>>>>>>> is what proves that there can't be a decider that gets >>>>>>>>>>>>>>>> all input right.
I did not say that precisely enough.
Both of the simulated inputs [WOULD] loop if their >>>>>>>>>>>>>>> corresponding halt
decider [WOULD] return {halts} to them and [WOULD] halt >>>>>>>>>>>>>>> loop if their
corresponding halt decider [WOULD] return {non-halting} >>>>>>>>>>>>>>> to them yet the
actual case is that they remain stuck in recursive >>>>>>>>>>>>>>> simulation until
their corresponding halt decider stops simulating them. >>>>>>>>>>>>>>>
Thus as you admitted for the H/D pair also applies to the >>>>>>>>>>>>>>> embedded_H / ⟨Ĥ⟩ pair. The simulated input cannot >>>>>>>>>>>>>>> possibly terminate
normally because it remains stuck in recursive simulation >>>>>>>>>>>>>>> until the
simulation is terminated *IN BOTH CASES*
You seem to be acting like the HBO Westworld character >>>>>>>>>>>>>> Bernard that was
a robot (AKA host) was almost perfectly a very smart human >>>>>>>>>>>>>> except that
his brain was hard-wired to not be able to "see" a >>>>>>>>>>>>>> specific door.
Then, once they're inside the dark house where Ford's >>>>>>>>>>>>>> robotic family
lives, Theresa asks what's behind one of the doors. "What >>>>>>>>>>>>>> door?" Bernard
asks, and that's when you know he's a host as well. The >>>>>>>>>>>>>> door is plain as
day, even in the dark, and he's been there before. And >>>>>>>>>>>>>> yet, he couldn't
see it.
https://www.forbes.com/sites/erikkain/2016/11/14/one-of-the-biggest-westworld-fan-theories-just-came-true/?sh=5bcd83a38a3e
So, where do Main -> H(D,D) and main -> D(D) -> H(D,D) >>>>>>>>>>>>> differ in their execution path?
You claim they differ, so show it.
If you really do know software engineering then you already >>>>>>>>>>>> know on the
basis that you already agreed that D simulated by H cannot >>>>>>>>>>>> terminate
normally.
Yes, but the question isn't what does the (partial)
simulation by H show, but what does the machine repesented by >>>>>>>>>>> the input do.
Since H doesn't simulate all of the behavior of D, its
simulation doesn't directly prove that answer.
When you ask a question that you already know the answer to >>>>>>>>>>>> then you are
only playing head games.
Excdpt what the simulation by H does isn't the question that >>>>>>>>>>> H is supposed to be answering.
That, or you are claiming that a "Correct Simulation" can >>>>>>>>>>>>> differ from the actual machine behavior, despite that going >>>>>>>>>>>>> against the definition.
You already admitted that D simulated by H never terminates >>>>>>>>>>>> normally.
Thus you knew that H is correct to abort its simulation of D >>>>>>>>>>>> to prevent
its own infinite execution.
H is allowed to abort its simulation for any reason its
programmer wants. It still needs to give the right answer to >>>>>>>>>>> be correct, and that answer needs to describe the behavior of >>>>>>>>>>> directly running the machine given an input.
Since H(D,D) has been said to return 0, we can by simple >>>>>>>>>>> inspection, and verify by actually running it, see that D(D) >>>>>>>>>>> will Halt, which means that H's answer is just wrong.
It might be a correct POOP decider, but only you seem
interested in your POOP.
The reason that I did this concretely in C is the there is >>>>>>>>>>>> no wiggle
room of ambiguity to deny what is actually occurring.
My way results in a halt decider that recognizes the actual >>>>>>>>>> behavior of
the actual input so that it doesn't get stuck in recursive >>>>>>>>>> simulation.
No, becase the ACTUAL BEHAVIOR of the machine in question is >>>>>>>>> what it does when actually run.
invocation.
Can D correctly simulated by H terminate normally?
Why does that matter?
Since H is being asked about the actual execution of D(D).
*This is factually incorrect*
H is only being asked about the behavior of its input.
Which is DEFINED as the Behavior of the Machine it describes.
H is not being asked about the behavior of a non-input.
So, you think the x86 code of a program isn't a suitable
description of an x86 program?
You already know that a decider computes the mapping
*from its input* to its own accept or reject state.
Right, and the "Input" is a description of a machine it is to
decide the behavior of.
In fact, you CAN define the behavior basd on simulation, as long as
the simulation is of the right sort, that of an UNCONDITION
COMPLETE SIMULATION.
H needs to answer about what your x86 simulator, if put into pure
simulation mode, would do when simulating the input to H.
That is its exact input, just not what it itself would do with it.
That is the difference between accurately simulating an input and
deciding on it. Accurate simulations of a non-halting input take
forever, deciding on it must take finite time.
Thus, H(P,d) needs to decide what UTM(P,d) would do with the exact
same input. Note, D calls H, not the machine simulating it, so
UTM(D,D) would see D(D) calling H(D.D) and what H(D,D) does with
that input.
The behavior of the non-input is the behavior that is one
recursive invocation removed from the behavior of its input.
Nope, You are just proving you don't understand a THING about the
problem
I guess this is why you can't understand how Turing Machine works.
They are defined simply enough you can't twist them.
H uses an x86 emulator to correctly simulate D.
No, it partially simulates the execution path o D.
Since you ar equating simulation to direct execution, the only
meaning of correct includes being COMPLETE.
01 int D(int (*x)())
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
*Execution Trace*
main() calls H(D,D) that simulates D(D) at line 11
*keeps repeating*
simulated D(D) calls simulated H(D,D) that simulates D(D) at
line 03 ...
You keep disagreeing with the easily verified fact that D correctly
On 5/24/23 4:20 PM, olcott wrote:
On 5/24/2023 2:12 PM, Richard Damon wrote:
On 5/24/23 2:45 PM, olcott wrote:
On 5/24/2023 1:10 PM, Richard Damon wrote:
On 5/24/23 2:02 PM, olcott wrote:
On 5/24/2023 12:00 PM, Richard Damon wrote:
On 5/24/23 12:09 PM, olcott wrote:
On 5/24/2023 10:57 AM, Richard Damon wrote:
On 5/24/23 11:47 AM, olcott wrote:
On 5/23/2023 7:38 PM, Richard Damon wrote:
On 5/23/23 9:50 AM, olcott wrote:You keep insisting on staying out-of-sync by one recursive >>>>>>>>>> invocation.
On 5/23/2023 6:44 AM, Richard Damon wrote:
On 5/22/23 11:31 PM, olcott wrote:My way results in a halt decider that recognizes the actual >>>>>>>>>>>> behavior of
On 5/22/2023 10:12 PM, Richard Damon wrote:
On 5/22/23 10:49 PM, olcott wrote:
On 5/22/2023 9:27 PM, olcott wrote:
On 5/22/2023 9:02 PM, Richard Damon wrote:
On 5/22/23 9:33 PM, olcott wrote:
On 5/22/2023 6:22 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 5/22/23 10:22 AM, olcott wrote:
On 5/21/2023 2:02 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 5/21/23 2:50 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/21/2023 1:39 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/21/23 2:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/21/2023 11:54 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/21/23 10:16 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 6:52 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 5:29 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 4:24 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 5:10 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 3:48 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 4:33 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 2:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 3:29 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 1:54 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
Yet any theory of computation computer scientist >>>>>>>>>>>>>>>>>>>>> knows that a simulationSo?Since you already acknowledged that D >>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated by H can never >>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally and you did not need an >>>>>>>>>>>>>>>>>>>>>>>>>>> infinite amount of time to >>>>>>>>>>>>>>>>>>>>>>>>>>> determine this then the isomorphic ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated by embedded_H >>>>>>>>>>>>>>>>>>>>>>>>>>> can also be determined to never terminate >>>>>>>>>>>>>>>>>>>>>>>>>>> normally and thisIt makes no error. As you already >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> admitted D correctly simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly terminate normally thus >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its isomorphism of ⟨Ĥ⟩ correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by embedded_H cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Right, but that affect the behavior of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ALL copies of it, since they all act the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same.*Yet only at the point where it aborts >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>On 5/20/23 2:46 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 1:15 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 1:09 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 11:10 AM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 11:24 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 10:19 AM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 10:54 AM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 8:49 AM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 12:00 AM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 10:27 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 11:00 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 9:51 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 8:56 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Wrong Question! >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> In other words the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question is over you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> head. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It took me many years >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to recognize this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same dodge by Ben. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, it is the WRONG >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question once you try >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to apply the answer to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the Halting Problem, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> which you do. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So the software >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> engineering really is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> over your head? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I see, so like Ben you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have never actually >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> written any code. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But you aren't talking >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about Software >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Engineering unless you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are lying about this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> applying to the Halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Problem described by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Linz, since that is the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Computability Theory. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Of course, the likely >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> explanation is that you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are just ignorant of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what you are talking >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about, so you don't >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand the diference. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ben kept masking his >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> coding incompetence >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this way. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It never occurred to me >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you have never >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> written any code. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have possibly written >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> more WORKING code than >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you have. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I don't believe you. Your >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inability to answer an >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> straight forward >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> software engineering >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question seems to prove >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> otherwise. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> What software engineering >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The answer to that question >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is NO, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Finally you admit an easily >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> verified fact. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but that is because H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't, and can never do an >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> accurarte simulation per the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a UTM. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the simulation by a UTM >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would be wrong then you would >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have to be able >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to point out the mistake in >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation of D by H, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, the simulation by a ACTUAL >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM will reach a final state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I don't know why you say this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when you already know that ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by embedded_H cannot >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because embedded_H doesn't >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually "Correctly Simulate" >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input by the definintion >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aquired by your mentioning of a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have already agreed that it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does simulate the first N steps >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly. It is just as obvious >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the behavior pattern of N >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ correctly simulated by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> even if the value of N is ∞. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>When a simulating halt decider >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulates N steps of its input >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it derives the exact same N steps >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that a pure UTM would derive because >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it is itself a UTM with extra features. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
But N steps in not ALL steps as >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> required by the actual definition >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of a UTM. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Actually N steps is the exact >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a UTM for those N steps. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Just like with the H/D example >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> after N steps we can see that neither >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D correctly simulated by H nor ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated by embedded_H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Nope, UTMs have no concept of only >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doing a partial simulation. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Just like a racing car is a street >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> legal care with extra features that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> makes it no longer street legal. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The fact that H aborts its simulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> part way means it is no longer a UTM >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Do you think you are immortal because >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you haven't died yet, and that everyone >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is immortal until the point in time they >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> die?
Since it just proves it isn't a UTM, it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can't assume that the copy it is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating is, it needs to account for >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that behavior. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The fact that the DESIGN logic to do >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this goes into an infinite loop, doesn't >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mean that the program itself does. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Since H aborts its simulation and >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> returns 0, its input will see its copy >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do exactly the same thing and thus will >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt, making the answer wrong. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Since H isn't a UTM, since if fails to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> meet the defintion, the fact that it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can't reach a final state is irrelevent, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as is any definiton of "Correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulation" that differs from what a UTM >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does.
UTM(D,D) Halts, therefore the CORRECT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SIMULATION (by a UTM which is what is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> allowed to replace the actual behavior >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the machine) Halts, and thus the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> CORRECT answer is Halting. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You are just showing that you have >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fallen for your own Strawman Deception >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that got you to use the wrong criteria. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
At this point where it aborts its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation we can see that it must >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do this to prevent its own infinite >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution, thus conclusively proving >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it correctly determined that its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
How much longer are you going to play >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the fool and deny this? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
No, it does so because it has been >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> programmed to do so, and thus ALL copies >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of it will do so. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
It makes the error assuming that the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> copy it is simulating will do something >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> different than it does. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Are you going to keep playing the fool on >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this?
Except that you are answering the wrong >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question.
In other words you want to keep playing the >>>>>>>>>>>>>>>>>>>>>>>>>>>>> fool and dodging the actual question that I >>>>>>>>>>>>>>>>>>>>>>>>>>>>> am actually asking.
No, you are showing yourself to be the fool >>>>>>>>>>>>>>>>>>>>>>>>>>>> by not understand your own stupidity. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
So you agreed that D correctly simulated H >>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly terminate >>>>>>>>>>>>>>>>>>>>>>>>>>>>> normally and the exact same thing goes for >>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ correctly simulated by >>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H.
No, I am saying that H can not correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulate the input H and give an answer. If >>>>>>>>>>>>>>>>>>>>>>>>>>>> H DOES try to correctly simulate its input, >>>>>>>>>>>>>>>>>>>>>>>>>>>> then it can never giv an answer. >>>>>>>>>>>>>>>>>>>>>>>>>>>
determination can be made in a finite amount >>>>>>>>>>>>>>>>>>>>>>>>>>> of time.
In both cases this can be correctly >>>>>>>>>>>>>>>>>>>>>>>>>>> determined after N steps of >>>>>>>>>>>>>>>>>>>>>>>>>>> simulation thus no need for the infinite >>>>>>>>>>>>>>>>>>>>>>>>>>> simulation that you keep >>>>>>>>>>>>>>>>>>>>>>>>>>> insisting is necessary.
You keep on LYING about what I said. Any H >>>>>>>>>>>>>>>>>>>>>>>>>> that gives an answer can not "Correctly >>>>>>>>>>>>>>>>>>>>>>>>>> Simulate" this input per the definitions that >>>>>>>>>>>>>>>>>>>>>>>>>> allow simulation to replace the behavior of >>>>>>>>>>>>>>>>>>>>>>>>>> the actual machine.
Since you already acknowledged that D correctly >>>>>>>>>>>>>>>>>>>>>>>>> simulated by H cannot
possibly terminate normally (hence [key >>>>>>>>>>>>>>>>>>>>>>>>> agreement]) and the H/D pair is >>>>>>>>>>>>>>>>>>>>>>>>> isomorphic to the embedded_H / ⟨Ĥ⟩ pair you >>>>>>>>>>>>>>>>>>>>>>>>> contradict yourself.
D(D) / Ĥ (Ĥ) still halt since H returns >>>>>>>>>>>>>>>>>>>>>>>> non-halting, thus that answer is wrong for the >>>>>>>>>>>>>>>>>>>>>>>> Halting Problem.
It only seems wrong because all of the textbooks >>>>>>>>>>>>>>>>>>>>>>> reject simulating
halt deciders out-of-hand without review >>>>>>>>>>>>>>>>>>>>>>> incorrectly assuming that
simulation cannot possibly be used as the basis >>>>>>>>>>>>>>>>>>>>>>> of a halt decider:
No, it is wrong because the question asks about >>>>>>>>>>>>>>>>>>>>>> the actual machine, and that halts, so the right >>>>>>>>>>>>>>>>>>>>>> answer is HALTING.
of N steps by a UTM does provide that actual >>>>>>>>>>>>>>>>>>>>> behavior of the actual
input to this UTM.
Nope, only if the machine reaches a final state in >>>>>>>>>>>>>>>>>>>> that Nth Step.
You just don't understand what a UTM is or what it >>>>>>>>>>>>>>>>>>>> does.
They also know that when the input to this UTM is >>>>>>>>>>>>>>>>>>>>> defined to have a
pathological relationship to this UTM that this >>>>>>>>>>>>>>>>>>>>> changes the behavior of
this correctly simulated input.
Nope, a UTM simulation is only correct if it exactly >>>>>>>>>>>>>>>>>>>> matches the FULL b4ehavior of the machine it is >>>>>>>>>>>>>>>>>>>> looking at. That is its DEFINITION.
Yes, do that, so anyone who actually understand the >>>>>>>>>>>>>>>>>>>> theory knows from that start that you are a crackpot. >>>>>>>>>>>>>>>>>>>>
Maybe I should begin my paper with this >>>>>>>>>>>>>>>>>>>>> self-evident truth before
proceeding to the notion of a simulating halt decider. >>>>>>>>>>>>>>>>>>>>
In any case the perfect isomorphism between H/D and >>>>>>>>>>>>>>>>>>>>> embedded_H / ⟨Ĥ⟩
already fully proves this point.
Why, since neither H or embedded_H are actually >>>>>>>>>>>>>>>>>>>> UTMs, and it is establishied that both of them >>>>>>>>>>>>>>>>>>>> declare their input to be non-halting when the >>>>>>>>>>>>>>>>>>>> machine they are given the description of Halt. >>>>>>>>>>>>>>>>>>>>
*Clearly you are clueless about what the term >>>>>>>>>>>>>>>>>>> isomorphism means*
Both D and ⟨Ĥ⟩ have the exact same form in that both >>>>>>>>>>>>>>>>>>> D and ⟨Ĥ⟩ attempt to
do the opposite of whatever their corresponding halt >>>>>>>>>>>>>>>>>>> decider determines.
Both of them loop when their halt decider returns >>>>>>>>>>>>>>>>>>> {halts} and both halt
when their halt decider returns {non-halting}. Both >>>>>>>>>>>>>>>>>>> of them continue to
call the halt decider in recursive simulation until >>>>>>>>>>>>>>>>>>> their halt decider
stops simulating them.
Right, so since the Halt Decider must have a defined >>>>>>>>>>>>>>>>>> behavior when given them as an input, that defined >>>>>>>>>>>>>>>>>> behavior will always be wrong, because no matter how >>>>>>>>>>>>>>>>>> you define your H, the machines will act the other >>>>>>>>>>>>>>>>>> way. This is what proves that there can't be a decider >>>>>>>>>>>>>>>>>> that gets all input right.
I did not say that precisely enough.
Both of the simulated inputs [WOULD] loop if their >>>>>>>>>>>>>>>>> corresponding halt
decider [WOULD] return {halts} to them and [WOULD] halt >>>>>>>>>>>>>>>>> loop if their
corresponding halt decider [WOULD] return {non-halting} >>>>>>>>>>>>>>>>> to them yet the
actual case is that they remain stuck in recursive >>>>>>>>>>>>>>>>> simulation until
their corresponding halt decider stops simulating them. >>>>>>>>>>>>>>>>>
Thus as you admitted for the H/D pair also applies to the >>>>>>>>>>>>>>>>> embedded_H / ⟨Ĥ⟩ pair. The simulated input cannot >>>>>>>>>>>>>>>>> possibly terminate
normally because it remains stuck in recursive >>>>>>>>>>>>>>>>> simulation until the
simulation is terminated *IN BOTH CASES*
You seem to be acting like the HBO Westworld character >>>>>>>>>>>>>>>> Bernard that was
a robot (AKA host) was almost perfectly a very smart >>>>>>>>>>>>>>>> human except that
his brain was hard-wired to not be able to "see" a >>>>>>>>>>>>>>>> specific door.
Then, once they're inside the dark house where Ford's >>>>>>>>>>>>>>>> robotic family
lives, Theresa asks what's behind one of the doors. >>>>>>>>>>>>>>>> "What door?" Bernard
asks, and that's when you know he's a host as well. The >>>>>>>>>>>>>>>> door is plain as
day, even in the dark, and he's been there before. And >>>>>>>>>>>>>>>> yet, he couldn't
see it.
https://www.forbes.com/sites/erikkain/2016/11/14/one-of-the-biggest-westworld-fan-theories-just-came-true/?sh=5bcd83a38a3e
So, where do Main -> H(D,D) and main -> D(D) -> H(D,D) >>>>>>>>>>>>>>> differ in their execution path?
You claim they differ, so show it.
If you really do know software engineering then you >>>>>>>>>>>>>> already know on the
basis that you already agreed that D simulated by H cannot >>>>>>>>>>>>>> terminate
normally.
Yes, but the question isn't what does the (partial)
simulation by H show, but what does the machine repesented >>>>>>>>>>>>> by the input do.
Since H doesn't simulate all of the behavior of D, its >>>>>>>>>>>>> simulation doesn't directly prove that answer.
When you ask a question that you already know the answer >>>>>>>>>>>>>> to then you are
only playing head games.
Excdpt what the simulation by H does isn't the question >>>>>>>>>>>>> that H is supposed to be answering.
That, or you are claiming that a "Correct Simulation" can >>>>>>>>>>>>>>> differ from the actual machine behavior, despite that >>>>>>>>>>>>>>> going against the definition.
You already admitted that D simulated by H never
terminates normally.
Thus you knew that H is correct to abort its simulation of >>>>>>>>>>>>>> D to prevent
its own infinite execution.
H is allowed to abort its simulation for any reason its >>>>>>>>>>>>> programmer wants. It still needs to give the right answer >>>>>>>>>>>>> to be correct, and that answer needs to describe the >>>>>>>>>>>>> behavior of directly running the machine given an input. >>>>>>>>>>>>>
Since H(D,D) has been said to return 0, we can by simple >>>>>>>>>>>>> inspection, and verify by actually running it, see that >>>>>>>>>>>>> D(D) will Halt, which means that H's answer is just wrong. >>>>>>>>>>>>>
It might be a correct POOP decider, but only you seem >>>>>>>>>>>>> interested in your POOP.
The reason that I did this concretely in C is the there is >>>>>>>>>>>>>> no wiggle
room of ambiguity to deny what is actually occurring. >>>>>>>>>>>>
the actual input so that it doesn't get stuck in recursive >>>>>>>>>>>> simulation.
No, becase the ACTUAL BEHAVIOR of the machine in question is >>>>>>>>>>> what it does when actually run.
Can D correctly simulated by H terminate normally?
Why does that matter?
Since H is being asked about the actual execution of D(D).
*This is factually incorrect*
H is only being asked about the behavior of its input.
Which is DEFINED as the Behavior of the Machine it describes.
H is not being asked about the behavior of a non-input.
So, you think the x86 code of a program isn't a suitable
description of an x86 program?
You already know that a decider computes the mapping
*from its input* to its own accept or reject state.
Right, and the "Input" is a description of a machine it is to
decide the behavior of.
In fact, you CAN define the behavior basd on simulation, as long >>>>>>> as the simulation is of the right sort, that of an UNCONDITION
COMPLETE SIMULATION.
H needs to answer about what your x86 simulator, if put into pure >>>>>>> simulation mode, would do when simulating the input to H.
That is its exact input, just not what it itself would do with
it. That is the difference between accurately simulating an input >>>>>>> and deciding on it. Accurate simulations of a non-halting input
take forever, deciding on it must take finite time.
On 5/24/2023 2:12 PM, Richard Damon wrote:
On 5/24/23 2:45 PM, olcott wrote:
On 5/24/2023 1:10 PM, Richard Damon wrote:
On 5/24/23 2:02 PM, olcott wrote:
On 5/24/2023 12:00 PM, Richard Damon wrote:
On 5/24/23 12:09 PM, olcott wrote:
On 5/24/2023 10:57 AM, Richard Damon wrote:
On 5/24/23 11:47 AM, olcott wrote:
On 5/23/2023 7:38 PM, Richard Damon wrote:
On 5/23/23 9:50 AM, olcott wrote:You keep insisting on staying out-of-sync by one recursive
On 5/23/2023 6:44 AM, Richard Damon wrote:
On 5/22/23 11:31 PM, olcott wrote:
On 5/22/2023 10:12 PM, Richard Damon wrote:
On 5/22/23 10:49 PM, olcott wrote:
On 5/22/2023 9:27 PM, olcott wrote:
On 5/22/2023 9:02 PM, Richard Damon wrote:
On 5/22/23 9:33 PM, olcott wrote:
On 5/22/2023 6:22 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 5/22/23 10:22 AM, olcott wrote:
On 5/21/2023 2:02 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 5/21/23 2:50 PM, olcott wrote:
Yet any theory of computation computer scientist >>>>>>>>>>>>>>>>>>>> knows that a simulationOn 5/21/2023 1:39 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/21/23 2:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/21/2023 11:54 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/21/23 10:16 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 6:52 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 5:29 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 4:24 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 5:10 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 3:48 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 4:33 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 2:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 3:29 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 1:54 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
So?Since you already acknowledged that D >>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated by H can never >>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally and you did not need an >>>>>>>>>>>>>>>>>>>>>>>>>> infinite amount of time to >>>>>>>>>>>>>>>>>>>>>>>>>> determine this then the isomorphic ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated by embedded_H >>>>>>>>>>>>>>>>>>>>>>>>>> can also be determined to never terminate >>>>>>>>>>>>>>>>>>>>>>>>>> normally and thisIt makes no error. As you already admitted >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D correctly simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly terminate normally thus >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its isomorphism of ⟨Ĥ⟩ correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by embedded_H cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Right, but that affect the behavior of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ALL copies of it, since they all act the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same.*Yet only at the point where it aborts >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>On 5/20/23 2:46 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 1:15 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 1:09 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 11:10 AM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 11:24 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 10:19 AM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 10:54 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 8:49 AM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 12:00 AM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 10:27 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 11:00 PM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 9:51 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 8:56 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Wrong Question! >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> In other words the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question is over you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> head. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It took me many years >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to recognize this same >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dodge by Ben. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, it is the WRONG >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question once you try >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to apply the answer to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the Halting Problem, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> which you do. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So the software >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> engineering really is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> over your head? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I see, so like Ben you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have never actually >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> written any code. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But you aren't talking >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about Software >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Engineering unless you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are lying about this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> applying to the Halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Problem described by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Linz, since that is the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Computability Theory. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Of course, the likely >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> explanation is that you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are just ignorant of what >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are talking about, so >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you don't understand the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> diference. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ben kept masking his >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> coding incompetence this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> way. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It never occurred to me >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you have never >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> written any code. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have possibly written >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> more WORKING code than >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you have. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I don't believe you. Your >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inability to answer an >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> straight forward >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> software engineering >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question seems to prove >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> otherwise. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> What software engineering >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The answer to that question >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is NO, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Finally you admit an easily >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> verified fact. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but that is because H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't, and can never do an >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> accurarte simulation per the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a UTM. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the simulation by a UTM >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would be wrong then you would >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have to be able >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to point out the mistake in >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation of D by H, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, the simulation by a ACTUAL >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM will reach a final state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I don't know why you say this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when you already know that ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by embedded_H cannot >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>When a simulating halt decider >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulates N steps of its input >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it derives the exact same N steps that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a pure UTM would derive because >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it is itself a UTM with extra features. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You have already agreed that it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does simulate the first N steps >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly. It is just as obvious >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the behavior pattern of N >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ correctly simulated by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> even if the value of N is ∞. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Because embedded_H doesn't >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually "Correctly Simulate" its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input by the definintion aquired >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by your mentioning of a UTM. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
But N steps in not ALL steps as >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> required by the actual definition >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of a UTM. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Actually N steps is the exact >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a UTM for those N steps. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Just like with the H/D example after >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> N steps we can see that neither >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D correctly simulated by H nor ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated by embedded_H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Nope, UTMs have no concept of only >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doing a partial simulation. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Just like a racing car is a street >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> legal care with extra features that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> makes it no longer street legal. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The fact that H aborts its simulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> part way means it is no longer a UTM >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Do you think you are immortal because you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> haven't died yet, and that everyone is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> immortal until the point in time they die? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Since it just proves it isn't a UTM, it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can't assume that the copy it is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating is, it needs to account for >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that behavior.
The fact that the DESIGN logic to do this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> goes into an infinite loop, doesn't mean >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the program itself does. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Since H aborts its simulation and returns >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 0, its input will see its copy do exactly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same thing and thus will Halt, making >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the answer wrong. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Since H isn't a UTM, since if fails to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> meet the defintion, the fact that it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can't reach a final state is irrelevent, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as is any definiton of "Correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulation" that differs from what a UTM >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does.
UTM(D,D) Halts, therefore the CORRECT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SIMULATION (by a UTM which is what is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> allowed to replace the actual behavior of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the machine) Halts, and thus the CORRECT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer is Halting. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You are just showing that you have fallen >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for your own Strawman Deception that got >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you to use the wrong criteria. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
At this point where it aborts its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation we can see that it must >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do this to prevent its own infinite >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution, thus conclusively proving >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it correctly determined that its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
How much longer are you going to play >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the fool and deny this? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
No, it does so because it has been >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> programmed to do so, and thus ALL copies >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of it will do so. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
It makes the error assuming that the copy >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it is simulating will do something >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> different than it does. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Are you going to keep playing the fool on >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this?
Except that you are answering the wrong >>>>>>>>>>>>>>>>>>>>>>>>>>>>> question.
In other words you want to keep playing the >>>>>>>>>>>>>>>>>>>>>>>>>>>> fool and dodging the actual question that I >>>>>>>>>>>>>>>>>>>>>>>>>>>> am actually asking.
No, you are showing yourself to be the fool >>>>>>>>>>>>>>>>>>>>>>>>>>> by not understand your own stupidity. >>>>>>>>>>>>>>>>>>>>>>>>>>>
So you agreed that D correctly simulated H >>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly terminate >>>>>>>>>>>>>>>>>>>>>>>>>>>> normally and the exact same thing goes for >>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ correctly simulated by >>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H.
No, I am saying that H can not correctly >>>>>>>>>>>>>>>>>>>>>>>>>>> simulate the input H and give an answer. If H >>>>>>>>>>>>>>>>>>>>>>>>>>> DOES try to correctly simulate its input, >>>>>>>>>>>>>>>>>>>>>>>>>>> then it can never giv an answer. >>>>>>>>>>>>>>>>>>>>>>>>>>
determination can be made in a finite amount >>>>>>>>>>>>>>>>>>>>>>>>>> of time.
In both cases this can be correctly determined >>>>>>>>>>>>>>>>>>>>>>>>>> after N steps of
simulation thus no need for the infinite >>>>>>>>>>>>>>>>>>>>>>>>>> simulation that you keep
insisting is necessary.
You keep on LYING about what I said. Any H that >>>>>>>>>>>>>>>>>>>>>>>>> gives an answer can not "Correctly Simulate" >>>>>>>>>>>>>>>>>>>>>>>>> this input per the definitions that allow >>>>>>>>>>>>>>>>>>>>>>>>> simulation to replace the behavior of the >>>>>>>>>>>>>>>>>>>>>>>>> actual machine.
Since you already acknowledged that D correctly >>>>>>>>>>>>>>>>>>>>>>>> simulated by H cannot
possibly terminate normally (hence [key >>>>>>>>>>>>>>>>>>>>>>>> agreement]) and the H/D pair is >>>>>>>>>>>>>>>>>>>>>>>> isomorphic to the embedded_H / ⟨Ĥ⟩ pair you >>>>>>>>>>>>>>>>>>>>>>>> contradict yourself.
D(D) / Ĥ (Ĥ) still halt since H returns >>>>>>>>>>>>>>>>>>>>>>> non-halting, thus that answer is wrong for the >>>>>>>>>>>>>>>>>>>>>>> Halting Problem.
It only seems wrong because all of the textbooks >>>>>>>>>>>>>>>>>>>>>> reject simulating
halt deciders out-of-hand without review >>>>>>>>>>>>>>>>>>>>>> incorrectly assuming that
simulation cannot possibly be used as the basis of >>>>>>>>>>>>>>>>>>>>>> a halt decider:
No, it is wrong because the question asks about the >>>>>>>>>>>>>>>>>>>>> actual machine, and that halts, so the right answer >>>>>>>>>>>>>>>>>>>>> is HALTING.
of N steps by a UTM does provide that actual >>>>>>>>>>>>>>>>>>>> behavior of the actual
input to this UTM.
Nope, only if the machine reaches a final state in >>>>>>>>>>>>>>>>>>> that Nth Step.
You just don't understand what a UTM is or what it does. >>>>>>>>>>>>>>>>>>>
They also know that when the input to this UTM is >>>>>>>>>>>>>>>>>>>> defined to have a
pathological relationship to this UTM that this >>>>>>>>>>>>>>>>>>>> changes the behavior of
this correctly simulated input.
Nope, a UTM simulation is only correct if it exactly >>>>>>>>>>>>>>>>>>> matches the FULL b4ehavior of the machine it is >>>>>>>>>>>>>>>>>>> looking at. That is its DEFINITION.
Yes, do that, so anyone who actually understand the >>>>>>>>>>>>>>>>>>> theory knows from that start that you are a crackpot. >>>>>>>>>>>>>>>>>>>
Maybe I should begin my paper with this self-evident >>>>>>>>>>>>>>>>>>>> truth before
proceeding to the notion of a simulating halt decider. >>>>>>>>>>>>>>>>>>>
In any case the perfect isomorphism between H/D and >>>>>>>>>>>>>>>>>>>> embedded_H / ⟨Ĥ⟩
already fully proves this point.
Why, since neither H or embedded_H are actually UTMs, >>>>>>>>>>>>>>>>>>> and it is establishied that both of them declare >>>>>>>>>>>>>>>>>>> their input to be non-halting when the machine they >>>>>>>>>>>>>>>>>>> are given the description of Halt.
*Clearly you are clueless about what the term >>>>>>>>>>>>>>>>>> isomorphism means*
Both D and ⟨Ĥ⟩ have the exact same form in that both D >>>>>>>>>>>>>>>>>> and ⟨Ĥ⟩ attempt to
do the opposite of whatever their corresponding halt >>>>>>>>>>>>>>>>>> decider determines.
Both of them loop when their halt decider returns >>>>>>>>>>>>>>>>>> {halts} and both halt
when their halt decider returns {non-halting}. Both of >>>>>>>>>>>>>>>>>> them continue to
call the halt decider in recursive simulation until >>>>>>>>>>>>>>>>>> their halt decider
stops simulating them.
Right, so since the Halt Decider must have a defined >>>>>>>>>>>>>>>>> behavior when given them as an input, that defined >>>>>>>>>>>>>>>>> behavior will always be wrong, because no matter how >>>>>>>>>>>>>>>>> you define your H, the machines will act the other way. >>>>>>>>>>>>>>>>> This is what proves that there can't be a decider that >>>>>>>>>>>>>>>>> gets all input right.
I did not say that precisely enough.
Both of the simulated inputs [WOULD] loop if their >>>>>>>>>>>>>>>> corresponding halt
decider [WOULD] return {halts} to them and [WOULD] halt >>>>>>>>>>>>>>>> loop if their
corresponding halt decider [WOULD] return {non-halting} >>>>>>>>>>>>>>>> to them yet the
actual case is that they remain stuck in recursive >>>>>>>>>>>>>>>> simulation until
their corresponding halt decider stops simulating them. >>>>>>>>>>>>>>>>
Thus as you admitted for the H/D pair also applies to the >>>>>>>>>>>>>>>> embedded_H / ⟨Ĥ⟩ pair. The simulated input cannot >>>>>>>>>>>>>>>> possibly terminate
normally because it remains stuck in recursive >>>>>>>>>>>>>>>> simulation until the
simulation is terminated *IN BOTH CASES*
You seem to be acting like the HBO Westworld character >>>>>>>>>>>>>>> Bernard that was
a robot (AKA host) was almost perfectly a very smart >>>>>>>>>>>>>>> human except that
his brain was hard-wired to not be able to "see" a >>>>>>>>>>>>>>> specific door.
Then, once they're inside the dark house where Ford's >>>>>>>>>>>>>>> robotic family
lives, Theresa asks what's behind one of the doors. "What >>>>>>>>>>>>>>> door?" Bernard
asks, and that's when you know he's a host as well. The >>>>>>>>>>>>>>> door is plain as
day, even in the dark, and he's been there before. And >>>>>>>>>>>>>>> yet, he couldn't
see it.
https://www.forbes.com/sites/erikkain/2016/11/14/one-of-the-biggest-westworld-fan-theories-just-came-true/?sh=5bcd83a38a3e
So, where do Main -> H(D,D) and main -> D(D) -> H(D,D) >>>>>>>>>>>>>> differ in their execution path?
You claim they differ, so show it.
If you really do know software engineering then you already >>>>>>>>>>>>> know on the
basis that you already agreed that D simulated by H cannot >>>>>>>>>>>>> terminate
normally.
Yes, but the question isn't what does the (partial)
simulation by H show, but what does the machine repesented >>>>>>>>>>>> by the input do.
Since H doesn't simulate all of the behavior of D, its >>>>>>>>>>>> simulation doesn't directly prove that answer.
When you ask a question that you already know the answer to >>>>>>>>>>>>> then you are
only playing head games.
Excdpt what the simulation by H does isn't the question that >>>>>>>>>>>> H is supposed to be answering.
That, or you are claiming that a "Correct Simulation" can >>>>>>>>>>>>>> differ from the actual machine behavior, despite that >>>>>>>>>>>>>> going against the definition.
You already admitted that D simulated by H never terminates >>>>>>>>>>>>> normally.
Thus you knew that H is correct to abort its simulation of >>>>>>>>>>>>> D to prevent
its own infinite execution.
H is allowed to abort its simulation for any reason its >>>>>>>>>>>> programmer wants. It still needs to give the right answer to >>>>>>>>>>>> be correct, and that answer needs to describe the behavior >>>>>>>>>>>> of directly running the machine given an input.
Since H(D,D) has been said to return 0, we can by simple >>>>>>>>>>>> inspection, and verify by actually running it, see that D(D) >>>>>>>>>>>> will Halt, which means that H's answer is just wrong.
It might be a correct POOP decider, but only you seem
interested in your POOP.
The reason that I did this concretely in C is the there is >>>>>>>>>>>>> no wiggle
room of ambiguity to deny what is actually occurring.
My way results in a halt decider that recognizes the actual >>>>>>>>>>> behavior of
the actual input so that it doesn't get stuck in recursive >>>>>>>>>>> simulation.
No, becase the ACTUAL BEHAVIOR of the machine in question is >>>>>>>>>> what it does when actually run.
invocation.
Can D correctly simulated by H terminate normally?
Why does that matter?
Since H is being asked about the actual execution of D(D).
*This is factually incorrect*
H is only being asked about the behavior of its input.
Which is DEFINED as the Behavior of the Machine it describes.
H is not being asked about the behavior of a non-input.
So, you think the x86 code of a program isn't a suitable
description of an x86 program?
You already know that a decider computes the mapping
*from its input* to its own accept or reject state.
Right, and the "Input" is a description of a machine it is to
decide the behavior of.
In fact, you CAN define the behavior basd on simulation, as long
as the simulation is of the right sort, that of an UNCONDITION
COMPLETE SIMULATION.
H needs to answer about what your x86 simulator, if put into pure
simulation mode, would do when simulating the input to H.
That is its exact input, just not what it itself would do with it. >>>>>> That is the difference between accurately simulating an input and
deciding on it. Accurate simulations of a non-halting input take
forever, deciding on it must take finite time.
Thus, H(P,d) needs to decide what UTM(P,d) would do with the exact >>>>>> same input. Note, D calls H, not the machine simulating it, so
UTM(D,D) would see D(D) calling H(D.D) and what H(D,D) does with
that input.
The behavior of the non-input is the behavior that is one
recursive invocation removed from the behavior of its input.
Nope, You are just proving you don't understand a THING about the
problem
I guess this is why you can't understand how Turing Machine works. >>>>>> They are defined simply enough you can't twist them.
H uses an x86 emulator to correctly simulate D.
On 5/24/2023 4:26 PM, Richard Damon wrote:
On 5/24/23 4:20 PM, olcott wrote:
On 5/24/2023 2:12 PM, Richard Damon wrote:
On 5/24/23 2:45 PM, olcott wrote:
On 5/24/2023 1:10 PM, Richard Damon wrote:
On 5/24/23 2:02 PM, olcott wrote:
On 5/24/2023 12:00 PM, Richard Damon wrote:
On 5/24/23 12:09 PM, olcott wrote:
On 5/24/2023 10:57 AM, Richard Damon wrote:
On 5/24/23 11:47 AM, olcott wrote:
On 5/23/2023 7:38 PM, Richard Damon wrote:
On 5/23/23 9:50 AM, olcott wrote:You keep insisting on staying out-of-sync by one recursive >>>>>>>>>>> invocation.
On 5/23/2023 6:44 AM, Richard Damon wrote:
On 5/22/23 11:31 PM, olcott wrote:My way results in a halt decider that recognizes the actual >>>>>>>>>>>>> behavior of
On 5/22/2023 10:12 PM, Richard Damon wrote:
On 5/22/23 10:49 PM, olcott wrote:
On 5/22/2023 9:27 PM, olcott wrote:
On 5/22/2023 9:02 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 5/22/23 9:33 PM, olcott wrote:
On 5/22/2023 6:22 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 5/22/23 10:22 AM, olcott wrote:
On 5/21/2023 2:02 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/21/23 2:50 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/21/2023 1:39 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/21/23 2:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/21/2023 11:54 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/21/23 10:16 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 6:52 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 5:29 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 4:24 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 5:10 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 3:48 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 4:33 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 2:56 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
Yet any theory of computation computer scientist >>>>>>>>>>>>>>>>>>>>>> knows that a simulationSo?Since you already acknowledged that D >>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated by H can never >>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally and you did not need an >>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite amount of time to >>>>>>>>>>>>>>>>>>>>>>>>>>>> determine this then the isomorphic ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated by embedded_H >>>>>>>>>>>>>>>>>>>>>>>>>>>> can also be determined to never terminate >>>>>>>>>>>>>>>>>>>>>>>>>>>> normally and thisNo, you are showing yourself to be the fool >>>>>>>>>>>>>>>>>>>>>>>>>>>>> by not understand your own stupidity. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>It makes no error. As you already >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> admitted D correctly simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly terminate normally thus >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its isomorphism of ⟨Ĥ⟩ correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by embedded_H cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Right, but that affect the behavior of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ALL copies of it, since they all act >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same.On 5/20/23 3:29 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 1:54 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 2:46 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 1:15 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 1:09 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 11:10 AM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 11:24 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 10:19 AM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 10:54 AM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 8:49 AM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 12:00 AM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 10:27 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 11:00 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 9:51 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 8:56 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Wrong Question! >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> In other words the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question is over you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> head. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It took me many >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> years to recognize >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this same dodge by Ben. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, it is the WRONG >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question once you try >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to apply the answer >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to the Halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Problem, which you do. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So the software >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> engineering really is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> over your head? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I see, so like Ben you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have never actually >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> written any code. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But you aren't talking >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about Software >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Engineering unless you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are lying about this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> applying to the Halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Problem described by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Linz, since that is the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Computability Theory. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Of course, the likely >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> explanation is that you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are just ignorant of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what you are talking >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about, so you don't >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand the diference. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ben kept masking his >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> coding incompetence >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this way. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It never occurred to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> me that you have never >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> written any code. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have possibly written >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> more WORKING code than >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you have. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I don't believe you. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Your inability to answer >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an straight forward >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> software engineering >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question seems to prove >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> otherwise. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> What software engineering >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The answer to that question >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is NO, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Finally you admit an easily >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> verified fact. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but that is because H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't, and can never do >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an accurarte simulation per >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the definition of a UTM. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the simulation by a UTM >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would be wrong then you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would have to be able >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to point out the mistake in >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation of D by H, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, the simulation by a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ACTUAL UTM will reach a final >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I don't know why you say this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when you already know that ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by embedded_H cannot >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because embedded_H doesn't >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually "Correctly Simulate" >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input by the definintion >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aquired by your mentioning of a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have already agreed that it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does simulate the first N steps >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly. It is just as obvious >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the behavior pattern of N >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ correctly simulated by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> even if the value of N is ∞. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*Yet only at the point where it aborts >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
When a simulating halt decider >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulates N steps of its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputBut N steps in not ALL steps as >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> required by the actual definition >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of a UTM. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Actually N steps is the exact >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a UTM for those N >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Just like with the H/D example >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> after N steps we can see that neither >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D correctly simulated by H nor ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated by embedded_H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Nope, UTMs have no concept of only >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doing a partial simulation. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
it derives the exact same N steps >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that a pure UTM would derive because >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it is itself a UTM with extra features. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Just like a racing car is a street >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> legal care with extra features that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> makes it no longer street legal. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The fact that H aborts its simulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> part way means it is no longer a UTM >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Do you think you are immortal because >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you haven't died yet, and that everyone >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is immortal until the point in time >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> they die?
Since it just proves it isn't a UTM, it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can't assume that the copy it is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating is, it needs to account for >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that behavior. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The fact that the DESIGN logic to do >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this goes into an infinite loop, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't mean that the program itself does. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Since H aborts its simulation and >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> returns 0, its input will see its copy >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do exactly the same thing and thus will >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt, making the answer wrong. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Since H isn't a UTM, since if fails to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> meet the defintion, the fact that it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can't reach a final state is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> irrelevent, as is any definiton of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "Correct Simulation" that differs from >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what a UTM does. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
UTM(D,D) Halts, therefore the CORRECT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SIMULATION (by a UTM which is what is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> allowed to replace the actual behavior >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the machine) Halts, and thus the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> CORRECT answer is Halting. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You are just showing that you have >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fallen for your own Strawman Deception >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that got you to use the wrong criteria. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
At this point where it aborts its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation we can see that it must >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do this to prevent its own infinite >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution, thus conclusively proving >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it correctly determined that its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
How much longer are you going to play >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the fool and deny this? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
No, it does so because it has been >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> programmed to do so, and thus ALL >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> copies of it will do so. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
It makes the error assuming that the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> copy it is simulating will do something >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> different than it does. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Are you going to keep playing the fool >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on this?
Except that you are answering the wrong >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question.
In other words you want to keep playing >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the fool and dodging the actual question >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that I am actually asking. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
So you agreed that D correctly simulated H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly terminate >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normally and the exact same thing goes for >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ correctly simulated by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H.
No, I am saying that H can not correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulate the input H and give an answer. If >>>>>>>>>>>>>>>>>>>>>>>>>>>>> H DOES try to correctly simulate its input, >>>>>>>>>>>>>>>>>>>>>>>>>>>>> then it can never giv an answer. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
determination can be made in a finite amount >>>>>>>>>>>>>>>>>>>>>>>>>>>> of time.
In both cases this can be correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>> determined after N steps of >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation thus no need for the infinite >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation that you keep >>>>>>>>>>>>>>>>>>>>>>>>>>>> insisting is necessary. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
You keep on LYING about what I said. Any H >>>>>>>>>>>>>>>>>>>>>>>>>>> that gives an answer can not "Correctly >>>>>>>>>>>>>>>>>>>>>>>>>>> Simulate" this input per the definitions that >>>>>>>>>>>>>>>>>>>>>>>>>>> allow simulation to replace the behavior of >>>>>>>>>>>>>>>>>>>>>>>>>>> the actual machine.
Since you already acknowledged that D >>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated by H cannot >>>>>>>>>>>>>>>>>>>>>>>>>> possibly terminate normally (hence [key >>>>>>>>>>>>>>>>>>>>>>>>>> agreement]) and the H/D pair is >>>>>>>>>>>>>>>>>>>>>>>>>> isomorphic to the embedded_H / ⟨Ĥ⟩ pair you >>>>>>>>>>>>>>>>>>>>>>>>>> contradict yourself.
D(D) / Ĥ (Ĥ) still halt since H returns >>>>>>>>>>>>>>>>>>>>>>>>> non-halting, thus that answer is wrong for the >>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem.
It only seems wrong because all of the textbooks >>>>>>>>>>>>>>>>>>>>>>>> reject simulating
halt deciders out-of-hand without review >>>>>>>>>>>>>>>>>>>>>>>> incorrectly assuming that
simulation cannot possibly be used as the basis >>>>>>>>>>>>>>>>>>>>>>>> of a halt decider:
No, it is wrong because the question asks about >>>>>>>>>>>>>>>>>>>>>>> the actual machine, and that halts, so the right >>>>>>>>>>>>>>>>>>>>>>> answer is HALTING.
of N steps by a UTM does provide that actual >>>>>>>>>>>>>>>>>>>>>> behavior of the actual
input to this UTM.
Nope, only if the machine reaches a final state in >>>>>>>>>>>>>>>>>>>>> that Nth Step.
You just don't understand what a UTM is or what it >>>>>>>>>>>>>>>>>>>>> does.
They also know that when the input to this UTM is >>>>>>>>>>>>>>>>>>>>>> defined to have a
pathological relationship to this UTM that this >>>>>>>>>>>>>>>>>>>>>> changes the behavior of
this correctly simulated input.
Nope, a UTM simulation is only correct if it >>>>>>>>>>>>>>>>>>>>> exactly matches the FULL b4ehavior of the machine >>>>>>>>>>>>>>>>>>>>> it is looking at. That is its DEFINITION. >>>>>>>>>>>>>>>>>>>>>
Maybe I should begin my paper with this >>>>>>>>>>>>>>>>>>>>>> self-evident truth before
proceeding to the notion of a simulating halt >>>>>>>>>>>>>>>>>>>>>> decider.
Yes, do that, so anyone who actually understand the >>>>>>>>>>>>>>>>>>>>> theory knows from that start that you are a crackpot. >>>>>>>>>>>>>>>>>>>>>
In any case the perfect isomorphism between H/D >>>>>>>>>>>>>>>>>>>>>> and embedded_H / ⟨Ĥ⟩
already fully proves this point.
Why, since neither H or embedded_H are actually >>>>>>>>>>>>>>>>>>>>> UTMs, and it is establishied that both of them >>>>>>>>>>>>>>>>>>>>> declare their input to be non-halting when the >>>>>>>>>>>>>>>>>>>>> machine they are given the description of Halt. >>>>>>>>>>>>>>>>>>>>>
*Clearly you are clueless about what the term >>>>>>>>>>>>>>>>>>>> isomorphism means*
Both D and ⟨Ĥ⟩ have the exact same form in that both >>>>>>>>>>>>>>>>>>>> D and ⟨Ĥ⟩ attempt to
do the opposite of whatever their corresponding halt >>>>>>>>>>>>>>>>>>>> decider determines.
Both of them loop when their halt decider returns >>>>>>>>>>>>>>>>>>>> {halts} and both halt
when their halt decider returns {non-halting}. Both >>>>>>>>>>>>>>>>>>>> of them continue to
call the halt decider in recursive simulation until >>>>>>>>>>>>>>>>>>>> their halt decider
stops simulating them.
Right, so since the Halt Decider must have a defined >>>>>>>>>>>>>>>>>>> behavior when given them as an input, that defined >>>>>>>>>>>>>>>>>>> behavior will always be wrong, because no matter how >>>>>>>>>>>>>>>>>>> you define your H, the machines will act the other >>>>>>>>>>>>>>>>>>> way. This is what proves that there can't be a >>>>>>>>>>>>>>>>>>> decider that gets all input right.
I did not say that precisely enough.
Both of the simulated inputs [WOULD] loop if their >>>>>>>>>>>>>>>>>> corresponding halt
decider [WOULD] return {halts} to them and [WOULD] >>>>>>>>>>>>>>>>>> halt loop if their
corresponding halt decider [WOULD] return
{non-halting} to them yet the
actual case is that they remain stuck in recursive >>>>>>>>>>>>>>>>>> simulation until
their corresponding halt decider stops simulating them. >>>>>>>>>>>>>>>>>>
Thus as you admitted for the H/D pair also applies to the >>>>>>>>>>>>>>>>>> embedded_H / ⟨Ĥ⟩ pair. The simulated input cannot >>>>>>>>>>>>>>>>>> possibly terminate
normally because it remains stuck in recursive >>>>>>>>>>>>>>>>>> simulation until the
simulation is terminated *IN BOTH CASES*
You seem to be acting like the HBO Westworld character >>>>>>>>>>>>>>>>> Bernard that was
a robot (AKA host) was almost perfectly a very smart >>>>>>>>>>>>>>>>> human except that
his brain was hard-wired to not be able to "see" a >>>>>>>>>>>>>>>>> specific door.
Then, once they're inside the dark house where Ford's >>>>>>>>>>>>>>>>> robotic family
lives, Theresa asks what's behind one of the doors. >>>>>>>>>>>>>>>>> "What door?" Bernard
asks, and that's when you know he's a host as well. The >>>>>>>>>>>>>>>>> door is plain as
day, even in the dark, and he's been there before. And >>>>>>>>>>>>>>>>> yet, he couldn't
see it.
https://www.forbes.com/sites/erikkain/2016/11/14/one-of-the-biggest-westworld-fan-theories-just-came-true/?sh=5bcd83a38a3e
So, where do Main -> H(D,D) and main -> D(D) -> H(D,D) >>>>>>>>>>>>>>>> differ in their execution path?
You claim they differ, so show it.
If you really do know software engineering then you >>>>>>>>>>>>>>> already know on the
basis that you already agreed that D simulated by H >>>>>>>>>>>>>>> cannot terminate
normally.
Yes, but the question isn't what does the (partial) >>>>>>>>>>>>>> simulation by H show, but what does the machine repesented >>>>>>>>>>>>>> by the input do.
Since H doesn't simulate all of the behavior of D, its >>>>>>>>>>>>>> simulation doesn't directly prove that answer.
When you ask a question that you already know the answer >>>>>>>>>>>>>>> to then you are
only playing head games.
Excdpt what the simulation by H does isn't the question >>>>>>>>>>>>>> that H is supposed to be answering.
That, or you are claiming that a "Correct Simulation" >>>>>>>>>>>>>>>> can differ from the actual machine behavior, despite >>>>>>>>>>>>>>>> that going against the definition.
You already admitted that D simulated by H never >>>>>>>>>>>>>>> terminates normally.
Thus you knew that H is correct to abort its simulation >>>>>>>>>>>>>>> of D to prevent
its own infinite execution.
H is allowed to abort its simulation for any reason its >>>>>>>>>>>>>> programmer wants. It still needs to give the right answer >>>>>>>>>>>>>> to be correct, and that answer needs to describe the >>>>>>>>>>>>>> behavior of directly running the machine given an input. >>>>>>>>>>>>>>
Since H(D,D) has been said to return 0, we can by simple >>>>>>>>>>>>>> inspection, and verify by actually running it, see that >>>>>>>>>>>>>> D(D) will Halt, which means that H's answer is just wrong. >>>>>>>>>>>>>>
It might be a correct POOP decider, but only you seem >>>>>>>>>>>>>> interested in your POOP.
The reason that I did this concretely in C is the there >>>>>>>>>>>>>>> is no wiggle
room of ambiguity to deny what is actually occurring. >>>>>>>>>>>>>
the actual input so that it doesn't get stuck in recursive >>>>>>>>>>>>> simulation.
No, becase the ACTUAL BEHAVIOR of the machine in question is >>>>>>>>>>>> what it does when actually run.
Can D correctly simulated by H terminate normally?
Why does that matter?
Since H is being asked about the actual execution of D(D).
*This is factually incorrect*
H is only being asked about the behavior of its input.
Which is DEFINED as the Behavior of the Machine it describes.
H is not being asked about the behavior of a non-input.
So, you think the x86 code of a program isn't a suitable
description of an x86 program?
On 5/24/23 5:43 PM, olcott wrote:
On 5/24/2023 4:26 PM, Richard Damon wrote:
On 5/24/23 4:20 PM, olcott wrote:
On 5/24/2023 2:12 PM, Richard Damon wrote:
On 5/24/23 2:45 PM, olcott wrote:
On 5/24/2023 1:10 PM, Richard Damon wrote:
On 5/24/23 2:02 PM, olcott wrote:
On 5/24/2023 12:00 PM, Richard Damon wrote:
On 5/24/23 12:09 PM, olcott wrote:
On 5/24/2023 10:57 AM, Richard Damon wrote:
On 5/24/23 11:47 AM, olcott wrote:
On 5/23/2023 7:38 PM, Richard Damon wrote:
On 5/23/23 9:50 AM, olcott wrote:
On 5/23/2023 6:44 AM, Richard Damon wrote:
On 5/22/23 11:31 PM, olcott wrote:
On 5/22/2023 10:12 PM, Richard Damon wrote:
On 5/22/23 10:49 PM, olcott wrote:
On 5/22/2023 9:27 PM, olcott wrote:
On 5/22/2023 9:02 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 5/22/23 9:33 PM, olcott wrote:
On 5/22/2023 6:22 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 5/22/23 10:22 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/21/2023 2:02 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/21/23 2:50 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/21/2023 1:39 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/21/23 2:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/21/2023 11:54 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/21/23 10:16 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 6:52 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 5:29 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 4:24 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 5:10 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 3:48 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 4:33 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 2:56 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
Yet any theory of computation computer scientist >>>>>>>>>>>>>>>>>>>>>>> knows that a simulationSo?Since you already acknowledged that D >>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated by H can never >>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally and you did not need an >>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite amount of time to >>>>>>>>>>>>>>>>>>>>>>>>>>>>> determine this then the isomorphic ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated by embedded_H >>>>>>>>>>>>>>>>>>>>>>>>>>>>> can also be determined to never terminate >>>>>>>>>>>>>>>>>>>>>>>>>>>>> normally and thisNo, you are showing yourself to be the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fool by not understand your own stupidity. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>It makes no error. As you already >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> admitted D correctly simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly terminate normally thus >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its isomorphism of ⟨Ĥ⟩ correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by embedded_H cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Right, but that affect the behavior of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ALL copies of it, since they all act >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same.On 5/20/23 3:29 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 1:54 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 2:46 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 1:15 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 1:09 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 11:10 AM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 11:24 AM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 10:19 AM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 10:54 AM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 8:49 AM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 12:00 AM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 10:27 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 11:00 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 9:51 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 8:56 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by H terminate >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Wrong Question! >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> In other words the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question is over >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you head. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It took me many >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> years to recognize >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this same dodge by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ben. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, it is the WRONG >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question once you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> try to apply the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer to the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> which you do. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So the software >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> engineering really is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> over your head? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I see, so like Ben >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you have never >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually written any >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> code. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But you aren't talking >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about Software >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Engineering unless you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are lying about this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> applying to the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> described by Linz, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> since that is the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Computability Theory. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Of course, the likely >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> explanation is that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are just ignorant >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of what you are >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> talking about, so you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> don't understand the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> diference. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ben kept masking his >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> coding incompetence >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this way. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It never occurred to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> me that you have >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never written any code. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> written more WORKING >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> code than you have. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I don't believe you. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Your inability to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer an straight forward >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> software engineering >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question seems to prove >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> otherwise. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> What software >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> engineering question? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The answer to that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question is NO, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Finally you admit an easily >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> verified fact. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but that is because H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't, and can never do >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an accurarte simulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> per the definition of a UTM. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the simulation by a UTM >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would be wrong then you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would have to be able >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to point out the mistake in >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation of D by H, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, the simulation by a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ACTUAL UTM will reach a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I don't know why you say this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when you already know that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by embedded_H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly terminate >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because embedded_H doesn't >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually "Correctly Simulate" >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input by the definintion >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aquired by your mentioning of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a UTM. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have already agreed that it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does simulate the first N steps >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly. It is just as >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> obvious that the behavior >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern of N steps of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ correctly simulated by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> even if the value of N is ∞. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But N steps in not ALL steps as >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> required by the actual >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a UTM. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*Yet only at the point where it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborts its simulation* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
When a simulating halt decider >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulates N steps of its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it derives the exact same N steps >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that a pure UTM would derive because >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it is itself a UTM with extra >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> features. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Actually N steps is the exact >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a UTM for those N >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Just like with the H/D example >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> after N steps we can see that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> neither >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D correctly simulated by H nor >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ correctly simulated by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Nope, UTMs have no concept of only >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doing a partial simulation. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Just like a racing car is a street >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> legal care with extra features that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> makes it no longer street legal. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The fact that H aborts its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation part way means it is no >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> longer a UTM >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Do you think you are immortal because >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you haven't died yet, and that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> everyone is immortal until the point >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in time they die? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Since it just proves it isn't a UTM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it can't assume that the copy it is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating is, it needs to account for >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that behavior. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The fact that the DESIGN logic to do >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this goes into an infinite loop, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't mean that the program itself >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does.
Since H aborts its simulation and >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> returns 0, its input will see its copy >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do exactly the same thing and thus >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will Halt, making the answer wrong. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Since H isn't a UTM, since if fails to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> meet the defintion, the fact that it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can't reach a final state is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> irrelevent, as is any definiton of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "Correct Simulation" that differs from >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what a UTM does. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
UTM(D,D) Halts, therefore the CORRECT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SIMULATION (by a UTM which is what is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> allowed to replace the actual behavior >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the machine) Halts, and thus the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> CORRECT answer is Halting. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You are just showing that you have >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fallen for your own Strawman Deception >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that got you to use the wrong criteria. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
At this point where it aborts its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation we can see that it must >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do this to prevent its own infinite >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution, thus conclusively proving >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it correctly determined that its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
How much longer are you going to play >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the fool and deny this? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
No, it does so because it has been >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> programmed to do so, and thus ALL >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> copies of it will do so. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
It makes the error assuming that the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> copy it is simulating will do >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> something different than it does. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Are you going to keep playing the fool >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on this?
Except that you are answering the wrong >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question.
In other words you want to keep playing >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the fool and dodging the actual question >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that I am actually asking. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
So you agreed that D correctly simulated >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H cannot possibly terminate >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normally and the exact same thing goes >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for ⟨Ĥ⟩ correctly simulated by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H.
No, I am saying that H can not correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulate the input H and give an answer. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H DOES try to correctly simulate its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input, then it can never giv an answer. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
determination can be made in a finite >>>>>>>>>>>>>>>>>>>>>>>>>>>>> amount of time.
In both cases this can be correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>> determined after N steps of >>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation thus no need for the infinite >>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation that you keep >>>>>>>>>>>>>>>>>>>>>>>>>>>>> insisting is necessary. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You keep on LYING about what I said. Any H >>>>>>>>>>>>>>>>>>>>>>>>>>>> that gives an answer can not "Correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulate" this input per the definitions >>>>>>>>>>>>>>>>>>>>>>>>>>>> that allow simulation to replace the >>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of the actual machine. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
Since you already acknowledged that D >>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated by H cannot >>>>>>>>>>>>>>>>>>>>>>>>>>> possibly terminate normally (hence [key >>>>>>>>>>>>>>>>>>>>>>>>>>> agreement]) and the H/D pair is >>>>>>>>>>>>>>>>>>>>>>>>>>> isomorphic to the embedded_H / ⟨Ĥ⟩ pair you >>>>>>>>>>>>>>>>>>>>>>>>>>> contradict yourself.
D(D) / Ĥ (Ĥ) still halt since H returns >>>>>>>>>>>>>>>>>>>>>>>>>> non-halting, thus that answer is wrong for the >>>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem.
It only seems wrong because all of the >>>>>>>>>>>>>>>>>>>>>>>>> textbooks reject simulating
halt deciders out-of-hand without review >>>>>>>>>>>>>>>>>>>>>>>>> incorrectly assuming that
simulation cannot possibly be used as the basis >>>>>>>>>>>>>>>>>>>>>>>>> of a halt decider:
No, it is wrong because the question asks about >>>>>>>>>>>>>>>>>>>>>>>> the actual machine, and that halts, so the right >>>>>>>>>>>>>>>>>>>>>>>> answer is HALTING.
of N steps by a UTM does provide that actual >>>>>>>>>>>>>>>>>>>>>>> behavior of the actual
input to this UTM.
Nope, only if the machine reaches a final state in >>>>>>>>>>>>>>>>>>>>>> that Nth Step.
You just don't understand what a UTM is or what it >>>>>>>>>>>>>>>>>>>>>> does.
They also know that when the input to this UTM is >>>>>>>>>>>>>>>>>>>>>>> defined to have a
pathological relationship to this UTM that this >>>>>>>>>>>>>>>>>>>>>>> changes the behavior of
this correctly simulated input.
Nope, a UTM simulation is only correct if it >>>>>>>>>>>>>>>>>>>>>> exactly matches the FULL b4ehavior of the machine >>>>>>>>>>>>>>>>>>>>>> it is looking at. That is its DEFINITION. >>>>>>>>>>>>>>>>>>>>>>
Maybe I should begin my paper with this >>>>>>>>>>>>>>>>>>>>>>> self-evident truth before
proceeding to the notion of a simulating halt >>>>>>>>>>>>>>>>>>>>>>> decider.
Yes, do that, so anyone who actually understand >>>>>>>>>>>>>>>>>>>>>> the theory knows from that start that you are a >>>>>>>>>>>>>>>>>>>>>> crackpot.
In any case the perfect isomorphism between H/D >>>>>>>>>>>>>>>>>>>>>>> and embedded_H / ⟨Ĥ⟩
already fully proves this point. >>>>>>>>>>>>>>>>>>>>>>>
Why, since neither H or embedded_H are actually >>>>>>>>>>>>>>>>>>>>>> UTMs, and it is establishied that both of them >>>>>>>>>>>>>>>>>>>>>> declare their input to be non-halting when the >>>>>>>>>>>>>>>>>>>>>> machine they are given the description of Halt. >>>>>>>>>>>>>>>>>>>>>>
*Clearly you are clueless about what the term >>>>>>>>>>>>>>>>>>>>> isomorphism means*
Both D and ⟨Ĥ⟩ have the exact same form in that >>>>>>>>>>>>>>>>>>>>> both D and ⟨Ĥ⟩ attempt to
do the opposite of whatever their corresponding >>>>>>>>>>>>>>>>>>>>> halt decider determines.
Both of them loop when their halt decider returns >>>>>>>>>>>>>>>>>>>>> {halts} and both halt
when their halt decider returns {non-halting}. Both >>>>>>>>>>>>>>>>>>>>> of them continue to
call the halt decider in recursive simulation until >>>>>>>>>>>>>>>>>>>>> their halt decider
stops simulating them.
Right, so since the Halt Decider must have a defined >>>>>>>>>>>>>>>>>>>> behavior when given them as an input, that defined >>>>>>>>>>>>>>>>>>>> behavior will always be wrong, because no matter how >>>>>>>>>>>>>>>>>>>> you define your H, the machines will act the other >>>>>>>>>>>>>>>>>>>> way. This is what proves that there can't be a >>>>>>>>>>>>>>>>>>>> decider that gets all input right.
I did not say that precisely enough.
Both of the simulated inputs [WOULD] loop if their >>>>>>>>>>>>>>>>>>> corresponding halt
decider [WOULD] return {halts} to them and [WOULD] >>>>>>>>>>>>>>>>>>> halt loop if their
corresponding halt decider [WOULD] return >>>>>>>>>>>>>>>>>>> {non-halting} to them yet the
actual case is that they remain stuck in recursive >>>>>>>>>>>>>>>>>>> simulation until
their corresponding halt decider stops simulating them. >>>>>>>>>>>>>>>>>>>
Thus as you admitted for the H/D pair also applies to >>>>>>>>>>>>>>>>>>> the
embedded_H / ⟨Ĥ⟩ pair. The simulated input cannot >>>>>>>>>>>>>>>>>>> possibly terminate
normally because it remains stuck in recursive >>>>>>>>>>>>>>>>>>> simulation until the
simulation is terminated *IN BOTH CASES*
You seem to be acting like the HBO Westworld character >>>>>>>>>>>>>>>>>> Bernard that was
a robot (AKA host) was almost perfectly a very smart >>>>>>>>>>>>>>>>>> human except that
his brain was hard-wired to not be able to "see" a >>>>>>>>>>>>>>>>>> specific door.
Then, once they're inside the dark house where Ford's >>>>>>>>>>>>>>>>>> robotic family
lives, Theresa asks what's behind one of the doors. >>>>>>>>>>>>>>>>>> "What door?" Bernard
asks, and that's when you know he's a host as well. >>>>>>>>>>>>>>>>>> The door is plain as
day, even in the dark, and he's been there before. And >>>>>>>>>>>>>>>>>> yet, he couldn't
see it.
https://www.forbes.com/sites/erikkain/2016/11/14/one-of-the-biggest-westworld-fan-theories-just-came-true/?sh=5bcd83a38a3e
So, where do Main -> H(D,D) and main -> D(D) -> H(D,D) >>>>>>>>>>>>>>>>> differ in their execution path?
You claim they differ, so show it.
If you really do know software engineering then you >>>>>>>>>>>>>>>> already know on the
basis that you already agreed that D simulated by H >>>>>>>>>>>>>>>> cannot terminate
normally.
Yes, but the question isn't what does the (partial) >>>>>>>>>>>>>>> simulation by H show, but what does the machine
repesented by the input do.
Since H doesn't simulate all of the behavior of D, its >>>>>>>>>>>>>>> simulation doesn't directly prove that answer.
When you ask a question that you already know the answer >>>>>>>>>>>>>>>> to then you are
only playing head games.
Excdpt what the simulation by H does isn't the question >>>>>>>>>>>>>>> that H is supposed to be answering.
That, or you are claiming that a "Correct Simulation" >>>>>>>>>>>>>>>>> can differ from the actual machine behavior, despite >>>>>>>>>>>>>>>>> that going against the definition.
You already admitted that D simulated by H never >>>>>>>>>>>>>>>> terminates normally.
Thus you knew that H is correct to abort its simulation >>>>>>>>>>>>>>>> of D to prevent
its own infinite execution.
H is allowed to abort its simulation for any reason its >>>>>>>>>>>>>>> programmer wants. It still needs to give the right answer >>>>>>>>>>>>>>> to be correct, and that answer needs to describe the >>>>>>>>>>>>>>> behavior of directly running the machine given an input. >>>>>>>>>>>>>>>
Since H(D,D) has been said to return 0, we can by simple >>>>>>>>>>>>>>> inspection, and verify by actually running it, see that >>>>>>>>>>>>>>> D(D) will Halt, which means that H's answer is just wrong. >>>>>>>>>>>>>>>
It might be a correct POOP decider, but only you seem >>>>>>>>>>>>>>> interested in your POOP.
On 5/24/2023 5:29 PM, Richard Damon wrote:
On 5/24/23 5:43 PM, olcott wrote:
On 5/24/2023 4:26 PM, Richard Damon wrote:
On 5/24/23 4:20 PM, olcott wrote:
On 5/24/2023 2:12 PM, Richard Damon wrote:
On 5/24/23 2:45 PM, olcott wrote:
On 5/24/2023 1:10 PM, Richard Damon wrote:
On 5/24/23 2:02 PM, olcott wrote:
On 5/24/2023 12:00 PM, Richard Damon wrote:
On 5/24/23 12:09 PM, olcott wrote:
On 5/24/2023 10:57 AM, Richard Damon wrote:
On 5/24/23 11:47 AM, olcott wrote:
On 5/23/2023 7:38 PM, Richard Damon wrote:
On 5/23/23 9:50 AM, olcott wrote:
On 5/23/2023 6:44 AM, Richard Damon wrote:
On 5/22/23 11:31 PM, olcott wrote:
On 5/22/2023 10:12 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 5/22/23 10:49 PM, olcott wrote:
On 5/22/2023 9:27 PM, olcott wrote:
On 5/22/2023 9:02 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 5/22/23 9:33 PM, olcott wrote:You seem to be acting like the HBO Westworld >>>>>>>>>>>>>>>>>>> character Bernard that was
On 5/22/2023 6:22 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/22/23 10:22 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/21/2023 2:02 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/21/23 2:50 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/21/2023 1:39 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/21/23 2:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/21/2023 11:54 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/21/23 10:16 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 6:52 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 5:29 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 4:24 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 5:10 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 3:48 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
Yet any theory of computation computer scientist >>>>>>>>>>>>>>>>>>>>>>>> knows that a simulationSo?Since you already acknowledged that D >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated by H can never >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally and you did not need an >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite amount of time to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determine this then the isomorphic ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated by embedded_H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can also be determined to never terminate >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normally and thisNo, you are showing yourself to be the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fool by not understand your own stupidity. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>On 5/20/23 4:33 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 2:56 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 3:29 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 1:54 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 2:46 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 1:15 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 1:09 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 11:10 AM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 11:24 AM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 10:19 AM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 10:54 AM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 8:49 AM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 12:00 AM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 10:27 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 11:00 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 9:51 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 8:56 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by H terminate >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Wrong Question! >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> In other words the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question is over >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you head. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It took me many >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> years to recognize >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this same dodge by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ben. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, it is the WRONG >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question once you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> try to apply the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer to the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> which you do. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So the software >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> engineering really >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is over your head? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I see, so like Ben >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you have never >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually written any >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> code. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But you aren't >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> talking about >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Software Engineering >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unless you are lying >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about this applying >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to the Halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Problem described by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Linz, since that is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the Halting Problem >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of Computability Theory. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Of course, the likely >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> explanation is that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are just ignorant >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of what you are >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> talking about, so you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> don't understand the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> diference. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ben kept masking his >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> coding incompetence >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this way. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It never occurred to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> me that you have >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never written any code. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> written more WORKING >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> code than you have. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I don't believe you. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Your inability to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer an straight >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> forward >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> software engineering >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question seems to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove otherwise. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> What software >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> engineering question? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The answer to that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question is NO, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Finally you admit an >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> easily verified fact. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but that is because H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't, and can never do >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an accurarte simulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> per the definition of a UTM. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the simulation by a UTM >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would be wrong then you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would have to be able >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to point out the mistake >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in the simulation of D by H, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, the simulation by a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ACTUAL UTM will reach a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I don't know why you say >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this when you already know >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that ⟨Ĥ⟩ correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by embedded_H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly terminate >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because embedded_H doesn't >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually "Correctly Simulate" >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input by the definintion >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aquired by your mentioning of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a UTM. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have already agreed that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it does simulate the first N >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly. It is just as >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> obvious that the behavior >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern of N steps of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ correctly simulated by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> even if the value of N is ∞. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But N steps in not ALL steps as >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> required by the actual >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a UTM. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Actually N steps is the exact >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a UTM for those N >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Just like with the H/D example >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> after N steps we can see that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> neither >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D correctly simulated by H nor >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ correctly simulated by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>It makes no error. As you already >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> admitted D correctly simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly terminate normally >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> thus its isomorphism of ⟨Ĥ⟩ correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by embedded_H cannot >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Right, but that affect the behavior >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of ALL copies of it, since they all >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> act the same. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*Yet only at the point where it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborts its simulation* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Nope, UTMs have no concept of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> only doing a partial simulation. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>When a simulating halt decider >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulates N steps of its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it derives the exact same N steps >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that a pure UTM would derive because >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it is itself a UTM with extra >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> features. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Just like a racing car is a street >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> legal care with extra features that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> makes it no longer street legal. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The fact that H aborts its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation part way means it is no >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> longer a UTM >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Do you think you are immortal because >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you haven't died yet, and that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> everyone is immortal until the point >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in time they die? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Since it just proves it isn't a UTM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it can't assume that the copy it is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating is, it needs to account >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for that behavior. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The fact that the DESIGN logic to do >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this goes into an infinite loop, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't mean that the program itself >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does.
Since H aborts its simulation and >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> returns 0, its input will see its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> copy do exactly the same thing and >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> thus will Halt, making the answer wrong. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Since H isn't a UTM, since if fails >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to meet the defintion, the fact that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it can't reach a final state is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> irrelevent, as is any definiton of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "Correct Simulation" that differs >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from what a UTM does. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
UTM(D,D) Halts, therefore the CORRECT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SIMULATION (by a UTM which is what is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> allowed to replace the actual >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of the machine) Halts, and >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> thus the CORRECT answer is Halting. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You are just showing that you have >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fallen for your own Strawman >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Deception that got you to use the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong criteria. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
At this point where it aborts its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation we can see that it must >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do this to prevent its own infinite >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution, thus conclusively proving >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it correctly determined that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulated input cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
How much longer are you going to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> play the fool and deny this? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
No, it does so because it has been >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> programmed to do so, and thus ALL >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> copies of it will do so. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
It makes the error assuming that the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> copy it is simulating will do >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> something different than it does. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Are you going to keep playing the fool >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on this?
Except that you are answering the wrong >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question.
In other words you want to keep playing >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the fool and dodging the actual question >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that I am actually asking. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
So you agreed that D correctly simulated >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H cannot possibly terminate >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normally and the exact same thing goes >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for ⟨Ĥ⟩ correctly simulated by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H.
No, I am saying that H can not correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulate the input H and give an answer. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H DOES try to correctly simulate its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input, then it can never giv an answer. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
determination can be made in a finite >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> amount of time.
In both cases this can be correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determined after N steps of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation thus no need for the infinite >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation that you keep >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> insisting is necessary. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You keep on LYING about what I said. Any H >>>>>>>>>>>>>>>>>>>>>>>>>>>>> that gives an answer can not "Correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulate" this input per the definitions >>>>>>>>>>>>>>>>>>>>>>>>>>>>> that allow simulation to replace the >>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of the actual machine. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Since you already acknowledged that D >>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated by H cannot >>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly terminate normally (hence [key >>>>>>>>>>>>>>>>>>>>>>>>>>>> agreement]) and the H/D pair is >>>>>>>>>>>>>>>>>>>>>>>>>>>> isomorphic to the embedded_H / ⟨Ĥ⟩ pair you >>>>>>>>>>>>>>>>>>>>>>>>>>>> contradict yourself.
D(D) / Ĥ (Ĥ) still halt since H returns >>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting, thus that answer is wrong for >>>>>>>>>>>>>>>>>>>>>>>>>>> the Halting Problem.
It only seems wrong because all of the >>>>>>>>>>>>>>>>>>>>>>>>>> textbooks reject simulating >>>>>>>>>>>>>>>>>>>>>>>>>> halt deciders out-of-hand without review >>>>>>>>>>>>>>>>>>>>>>>>>> incorrectly assuming that
simulation cannot possibly be used as the >>>>>>>>>>>>>>>>>>>>>>>>>> basis of a halt decider:
No, it is wrong because the question asks about >>>>>>>>>>>>>>>>>>>>>>>>> the actual machine, and that halts, so the >>>>>>>>>>>>>>>>>>>>>>>>> right answer is HALTING.
of N steps by a UTM does provide that actual >>>>>>>>>>>>>>>>>>>>>>>> behavior of the actual
input to this UTM.
Nope, only if the machine reaches a final state >>>>>>>>>>>>>>>>>>>>>>> in that Nth Step.
You just don't understand what a UTM is or what >>>>>>>>>>>>>>>>>>>>>>> it does.
Nope, a UTM simulation is only correct if it >>>>>>>>>>>>>>>>>>>>>>> exactly matches the FULL b4ehavior of the machine >>>>>>>>>>>>>>>>>>>>>>> it is looking at. That is its DEFINITION. >>>>>>>>>>>>>>>>>>>>>>>
They also know that when the input to this UTM >>>>>>>>>>>>>>>>>>>>>>>> is defined to have a
pathological relationship to this UTM that this >>>>>>>>>>>>>>>>>>>>>>>> changes the behavior of
this correctly simulated input. >>>>>>>>>>>>>>>>>>>>>>>
Maybe I should begin my paper with this >>>>>>>>>>>>>>>>>>>>>>>> self-evident truth before
proceeding to the notion of a simulating halt >>>>>>>>>>>>>>>>>>>>>>>> decider.
Yes, do that, so anyone who actually understand >>>>>>>>>>>>>>>>>>>>>>> the theory knows from that start that you are a >>>>>>>>>>>>>>>>>>>>>>> crackpot.
In any case the perfect isomorphism between H/D >>>>>>>>>>>>>>>>>>>>>>>> and embedded_H / ⟨Ĥ⟩
already fully proves this point. >>>>>>>>>>>>>>>>>>>>>>>>
Why, since neither H or embedded_H are actually >>>>>>>>>>>>>>>>>>>>>>> UTMs, and it is establishied that both of them >>>>>>>>>>>>>>>>>>>>>>> declare their input to be non-halting when the >>>>>>>>>>>>>>>>>>>>>>> machine they are given the description of Halt. >>>>>>>>>>>>>>>>>>>>>>>
*Clearly you are clueless about what the term >>>>>>>>>>>>>>>>>>>>>> isomorphism means*
Both D and ⟨Ĥ⟩ have the exact same form in that >>>>>>>>>>>>>>>>>>>>>> both D and ⟨Ĥ⟩ attempt to
do the opposite of whatever their corresponding >>>>>>>>>>>>>>>>>>>>>> halt decider determines.
Both of them loop when their halt decider returns >>>>>>>>>>>>>>>>>>>>>> {halts} and both halt
when their halt decider returns {non-halting}. >>>>>>>>>>>>>>>>>>>>>> Both of them continue to
call the halt decider in recursive simulation >>>>>>>>>>>>>>>>>>>>>> until their halt decider
stops simulating them.
Right, so since the Halt Decider must have a >>>>>>>>>>>>>>>>>>>>> defined behavior when given them as an input, that >>>>>>>>>>>>>>>>>>>>> defined behavior will always be wrong, because no >>>>>>>>>>>>>>>>>>>>> matter how you define your H, the machines will act >>>>>>>>>>>>>>>>>>>>> the other way. This is what proves that there can't >>>>>>>>>>>>>>>>>>>>> be a decider that gets all input right. >>>>>>>>>>>>>>>>>>>>>
I did not say that precisely enough.
Both of the simulated inputs [WOULD] loop if their >>>>>>>>>>>>>>>>>>>> corresponding halt
decider [WOULD] return {halts} to them and [WOULD] >>>>>>>>>>>>>>>>>>>> halt loop if their
corresponding halt decider [WOULD] return >>>>>>>>>>>>>>>>>>>> {non-halting} to them yet the
actual case is that they remain stuck in recursive >>>>>>>>>>>>>>>>>>>> simulation until
their corresponding halt decider stops simulating them. >>>>>>>>>>>>>>>>>>>>
Thus as you admitted for the H/D pair also applies >>>>>>>>>>>>>>>>>>>> to the
embedded_H / ⟨Ĥ⟩ pair. The simulated input cannot >>>>>>>>>>>>>>>>>>>> possibly terminate
normally because it remains stuck in recursive >>>>>>>>>>>>>>>>>>>> simulation until the
simulation is terminated *IN BOTH CASES* >>>>>>>>>>>>>>>>>>>
a robot (AKA host) was almost perfectly a very smart >>>>>>>>>>>>>>>>>>> human except that
his brain was hard-wired to not be able to "see" a >>>>>>>>>>>>>>>>>>> specific door.
Then, once they're inside the dark house where Ford's >>>>>>>>>>>>>>>>>>> robotic family
lives, Theresa asks what's behind one of the doors. >>>>>>>>>>>>>>>>>>> "What door?" Bernard
asks, and that's when you know he's a host as well. >>>>>>>>>>>>>>>>>>> The door is plain as
day, even in the dark, and he's been there before. >>>>>>>>>>>>>>>>>>> And yet, he couldn't
see it.
https://www.forbes.com/sites/erikkain/2016/11/14/one-of-the-biggest-westworld-fan-theories-just-came-true/?sh=5bcd83a38a3e
So, where do Main -> H(D,D) and main -> D(D) -> H(D,D) >>>>>>>>>>>>>>>>>> differ in their execution path?
You claim they differ, so show it.
If you really do know software engineering then you >>>>>>>>>>>>>>>>> already know on the
basis that you already agreed that D simulated by H >>>>>>>>>>>>>>>>> cannot terminate
normally.
Yes, but the question isn't what does the (partial) >>>>>>>>>>>>>>>> simulation by H show, but what does the machine >>>>>>>>>>>>>>>> repesented by the input do.
Since H doesn't simulate all of the behavior of D, its >>>>>>>>>>>>>>>> simulation doesn't directly prove that answer. >>>>>>>>>>>>>>>>
When you ask a question that you already know the >>>>>>>>>>>>>>>>> answer to then you are
only playing head games.
Excdpt what the simulation by H does isn't the question >>>>>>>>>>>>>>>> that H is supposed to be answering.
That, or you are claiming that a "Correct Simulation" >>>>>>>>>>>>>>>>>> can differ from the actual machine behavior, despite >>>>>>>>>>>>>>>>>> that going against the definition.
You already admitted that D simulated by H never >>>>>>>>>>>>>>>>> terminates normally.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 297 |
| Nodes: | 16 (3 / 13) |
| Uptime: | 101:31:04 |
| Calls: | 6,660 |
| Calls today: | 2 |
| Files: | 12,209 |
| Messages: | 5,334,862 |