On 1/24/22 9:11 PM, olcott wrote:
On 1/24/2022 8:03 PM, Richard Damon wrote:
With logical entailment the conclusion follows from the premise(s) by
On 1/24/22 8:32 PM, olcott wrote:
On 1/24/2022 6:50 PM, Richard Damon wrote:
On 1/24/22 7:09 PM, olcott wrote:
On 1/24/2022 5:49 PM, Richard Damon wrote:
On 1/24/22 10:03 AM, olcott wrote:
On 1/23/2022 10:45 PM, Richard Damon wrote:
On 1/23/22 11:17 PM, olcott wrote:
On 1/23/2022 9:57 PM, Richard Damon wrote:
On 1/23/22 10:40 PM, olcott wrote:
On 1/23/2022 9:24 PM, Richard Damon wrote:WARNING, you are getting way into hypothecctica Unicoprn >>>>>>>>>>> Terretory, but lets unpack this statement.
On 1/23/22 10:10 PM, olcott wrote:
On 1/23/2022 8:42 PM, Richard Damon wrote:
On 1/23/22 9:29 PM, olcott wrote:
On 1/23/2022 8:14 PM, Richard Damon wrote:
On 1/23/22 9:03 PM, olcott wrote:
On 1/23/2022 7:55 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 1/23/22 8:10 PM, olcott wrote:
On 1/23/2022 7:00 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 1/23/22 7:25 PM, olcott wrote:
On 1/23/2022 6:09 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 7:00 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 5:50 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 6:16 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 5:06 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 5:47 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 4:40 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 5:18 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 4:01 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 4:40 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 2:25 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You deliberate weasel words do not apply to >>>>>>>>>>>>>>>>>>>>>>>>>> what I said:On 1/23/22 2:19 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 10:43 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
On 1/22/22 11:34 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 3:36 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 4:25 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 3:20 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>YOU JUST AREN'T BRIGHT ENOUGH TO GET >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THIS. IT CAN BE VERIFIED AS COMPLETELY >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> TRUE ENTIRELY ON THE BASIS OF THE >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> MEANING OF ITS WORDS. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Showing that you can do one case does >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not prove that the same method works >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on all, particularly harder methods. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Anyone that knows that x86 language >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can tell that its easy to match the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite loop pattern: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>This is true for infinite loops, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite recursion, infinitely >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> nested simulation and all other >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non halting inputs: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
When-so-ever any simulated input >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to any simulating halt decider >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would never reach the final state >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of this simulated input in any >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite number of steps it is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always correct for the simulating >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider to abort its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation and transition to its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reject state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Can you PROVE that statement, or is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this just one of your false 'self >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> evident truth'. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
_Infinite_Loop() >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fa](01) 55 push
ebp
[000015fb](02) 8bec mov
ebp,esp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fd](02) ebfe jmp
000015fd >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015ff](01) 5d pop ebp
[00001600](01) c3 ret
Size in bytes:(0007) [00001600] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
---[000015fa][002126f0][002126f4] 55 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fb][002126f0][002126f4] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fd][002126f0][002126f4] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebfe jmp 000015fd >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fd][002126f0][002126f4] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebfe jmp 000015fd >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
That is just you serving Red Herring. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
And that pattern does NOT show up in >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation by H of H^ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Which makes it MORE lies by Red Herring. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
FAIL.
Total lack of proof. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
LIE.Does the proof include the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> posibility that the input includes >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a copy of the decider? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
It is always the case that a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider can >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly base its halt status >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decision on the behavior pure >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Proven incorrect. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
If H -> H.Qn then H^ -> H^.Qn and >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halts and for H^ <H^> proves H wrong. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
We know that this must be true >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because we know that the pure UTM >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of an Turing Machine >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> description is defined to have >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> equivalent behavior to that of the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> direct execution of the same machine >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Right, but that does't prove what you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sy.
You are just LYING out of your POOP. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The problem is that IF the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider does abort >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input based on some condition, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then it is no longer a source of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> truth for the halting status of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that input. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
It is not answering the question: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does the input stop running? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
YOU need to answer, which H are you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> using?
If H doesn't abort, then H^ is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting, but H will never answer. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
If H does abort and go to H.Qn, then >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the pure simulation of the input WILL >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt at H^.Qn, so H was wrong. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
FAIL.
Right, and if H -> H.Qn it will. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
It is answering the question: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Would the pure simulation of the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input ever stop running? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
FAIL.
It is the case that if embedded_H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recognizes an infinitely repeating >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern in the simulation of its input >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> such that this correctly simulated >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input cannot possibly reach its final >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state then this is complete prove that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this simulated input never halts. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
If it COULD CORRECTLY recognize an >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely repeating pattern in its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation that can not possibly reach >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final state (when simulated by a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM, not just H) then, YES, H can go to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H.Qn.
The problem is that due to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 'pathological self-reference' in H^, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ANY pattern that H sees in its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of <H^> <H^> that it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> transitions to H.Qn, will BY >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DEFINITION, become a halting pattern. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
So a correctly simulated INPUT that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly reach its final state >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches its final state anyway. YOU ARE >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DUMBER THAN A BOX OF ROCKS !!! >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
That's not what I said, I said there is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> no pattern that H use to detect that it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> won't halt, as any pattern that H uses to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decide to go to H.Qn will be WRONG for H^ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as if H goes to H.Qn, then H^ also goes >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H^.Qn and Halts. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
When the correctly simulated INPUT to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H cannot possibly reach its final >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state it is necessarily correct for >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H to report that its correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT cannot possibly reach its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state.
Right, but you have only proved that H^ is >>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting for the case where H doesn't >>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Because you are dumber than a box of rocks >>>>>>>>>>>>>>>>>>>>>>>>>>>> (or perhaps you are a bot?) >>>>>>>>>>>>>>>>>>>>>>>>>>>> You did not notice that I never mentioned >>>>>>>>>>>>>>>>>>>>>>>>>>>> the word: "halting".
For a human being you are much dumber than a >>>>>>>>>>>>>>>>>>>>>>>>>>>> box of rocks.
For a bot you did quite well (you nearly >>>>>>>>>>>>>>>>>>>>>>>>>>>> passed the Turing test) it took me this long >>>>>>>>>>>>>>>>>>>>>>>>>>>> to realize that you are not a human being. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
But reaching final state is the same as Halting. >>>>>>>>>>>>>>>>>>>>>>>>>>>
You have only prove that the pure simulation >>>>>>>>>>>>>>>>>>>>>>>>>>> of the input to H never reaches a final state >>>>>>>>>>>>>>>>>>>>>>>>>>> for case when H doesn't abort its simulation. >>>>>>>>>>>>>>>>>>>>>>>>>>>
(1) Premise: When the correctly simulated >>>>>>>>>>>>>>>>>>>>>>>>>> INPUT to embedded_H cannot possibly reach its >>>>>>>>>>>>>>>>>>>>>>>>>> final state
(2) Conclusion: It is necessarily correct for >>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H to report that its correctly >>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT cannot possibly reach its >>>>>>>>>>>>>>>>>>>>>>>>>> final state.
And the correct simulation of the input to H is >>>>>>>>>>>>>>>>>>>>>>>>> determined by the UTM, not H. >>>>>>>>>>>>>>>>>>>>>>>>
(2) is a logical consequence of (1). >>>>>>>>>>>>>>>>>>>>>>>> It is logically incorrect to argue with a >>>>>>>>>>>>>>>>>>>>>>>> deductive logical premise.
But 1 is only true if H doesn't go to H.Qn, so H >>>>>>>>>>>>>>>>>>>>>>> can't correctly go to H.Qn.
You are quite the deceiver making sure to always >>>>>>>>>>>>>>>>>>>>>> change the subject rather than directly address >>>>>>>>>>>>>>>>>>>>>> the point at hand.
And you seem quite dense. I did NOT change the >>>>>>>>>>>>>>>>>>>>> subject, I pointed out an error in your statement. >>>>>>>>>>>>>>>>>>>>> You seem to be unable to comprehend that. >>>>>>>>>>>>>>>>>>>>>
But 1 ISN'T True if H <H^> <H^> -> H.Qn, as the >>>>>>>>>>>>>>>>>>>>> correctly simulate input
(2) logically follows from (1) is true. >>>>>>>>>>>>>>>>>>>>>
When testing whether or not one assertion logically >>>>>>>>>>>>>>>>>>>> follows from another the premises are always "given" >>>>>>>>>>>>>>>>>>>> to be true even if they are false.
Don't know what sort of logic you are claiming. >>>>>>>>>>>>>>>>>>>
And arguemnt with a false premise is unsound. >>>>>>>>>>>>>>>>>>>
We are not yet looking at soundness we are looking at >>>>>>>>>>>>>>>>>> validity.
It is true that (2) logically follows from (1). >>>>>>>>>>>>>>>>>> We can't move on from this one point until we have >>>>>>>>>>>>>>>>>> mutual agreement.
Very strange then, why are you arguing about that which >>>>>>>>>>>>>>>>> was accepted unless you disagree to the conditions that >>>>>>>>>>>>>>>>> they were accepted under?
It has long been accepted that the under the >>>>>>>>>>>>>>>>> hypothetical condition where H can actually determine >>>>>>>>>>>>>>>>> that the UTM will run forever, it is correct (and in >>>>>>>>>>>>>>>>> fact needed to be correct) for H to go to H.Qn and say >>>>>>>>>>>>>>>>> non-halting.
OKAY so then you agree with this?
(1) Premise: When the correctly simulated INPUT to >>>>>>>>>>>>>>>> embedded_H
cannot possibly reach its final state
(2) Conclusion: It is necessarily correct for embedded_H to >>>>>>>>>>>>>>>> report that its correctly simulated INPUT cannot possibly >>>>>>>>>>>>>>>> reach its final state.
Under the definition that 'correctly simulated input' is >>>>>>>>>>>>>>> as determined by a UTM, not H (if it aborts its simulation). >>>>>>>>>>>>>>>
It is only stipulated to be correct other details are >>>>>>>>>>>>>> currently unspecified.
That isn't a 'stipulation', that is a DEFINITION.
This is obviously your attempt at being a weasel.
The DEFINITION of correct simulation is the results of a >>>>>>>>>>>>> UTM simulating the input.
Any deviaiton in this means you are just eating your POOP. >>>>>>>>>>>>>
It also does not presume that H CAN determine that this >>>>>>>>>>>>>>> condition exists, so it would be correct, but H might not >>>>>>>>>>>>>>> be able to decide to do so. So it may be correct for it >>>>>>>>>>>>>>> to do so, but it might not actually be able to do it. >>>>>>>>>>>>>>>
There is also the case you tend to ignore that you start >>>>>>>>>>>>>>> with an H that is defined to NOT abort, but you try to >>>>>>>>>>>>>>> use (2) to claim that it now can abort, the H is (2) must >>>>>>>>>>>>>>> be the same H that the H^ in (1) was built form
All of these restrictions are actually in the actual >>>>>>>>>>>>>>> meaning of the words you are using, from the context of >>>>>>>>>>>>>>> the problem, but I state them because knowing you, you >>>>>>>>>>>>>>> are going to try to break that restrictions.
This seems to be the very first time that you actually >>>>>>>>>>>>>> paid close attention, good jo
As I asked, how is that different from the statement of >>>>>>>>>>>>>>> the requirements on H?
We define Linz H to base its halt status decision on the >>>>>>>>>>>>>> behavior of its pure simulation of N steps of its input. N >>>>>>>>>>>>>> is either the number of steps that it takes for its >>>>>>>>>>>>>> simulated input to reach its final state or the number of >>>>>>>>>>>>>> steps required for H to match an infinite behavior pattern >>>>>>>>>>>>>> proving that its simulated input would never reach its own >>>>>>>>>>>>>> final state. In this case H aborts the simulation of this >>>>>>>>>>>>>> input and transitions to H.qn.
Note, The correct answer is NOT based on a simulation of N >>>>>>>>>>>>> steps, but a simulation by a UTM which will run until it >>>>>>>>>>>>> halts.
H needs to make ITS decision on the limited N step, so it >>>>>>>>>>>>> needs to prove that its answer matches.
Remember, when we do this run, H is defined, and thus N is >>>>>>>>>>>>> a SPECIFIC number, not an 'arbitrary' number.
You also will need to some how prove that a pattern exists >>>>>>>>>>>>> in N steps that correct dectect non-halting.
This has been previously shown to be impossible, so you >>>>>>>>>>>>> need to actually come up with it or show an actual error in >>>>>>>>>>>>> the proof. You can't just assume it exists.
Great we can move to the next step:
(1) Premise: When embedded_H correctly determines its
simulated INPUT to
embedded_H cannot possibly reach its final state
(2) Conclusion: It is necessarily correct for embedded_H to >>>>>>>>>>>> report that its correctly simulated INPUT cannot possibly >>>>>>>>>>>> reach its final state.
IF H can correctly deteremine (that means that there needs to >>>>>>>>>>> exist a finite algroithm to determine this case, and that >>>>>>>>>>> this result matches the behavior demonstrated by the
definitional UTM simulataion of this input), that the input >>>>>>>>>>> will NEVER reach it final state,
Then yes, it is correct for H to report that its input can >>>>>>>>>>> not possible reach its final state.
Great we have finally begun an honest dialogue.
Note, that if H does this, then the proof that the input >>>>>>>>>>> never reached its final state must have included that fact >>>>>>>>>>> that the copy of H inside H^ will also do the exact same >>>>>>>>>>> thing with the exact same input.
Also, to show the premise is True, you need to be able to >>>>>>>>>>> PROVE or actually provide the exact finite algorithm that it >>>>>>>>>>> used to detemine this fact.
When embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ these steps would
keep repeating:
Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
⟨Ĥ⟩...
Only if H doesn't abort it simulation.
On the basis that the pure simulation of N steps matches an
infinitely repeating pattern embedded_H can correctly determine >>>>>>>> that this simulated input cannot possibly reach its final state >>>>>>>> whether or not embedded_H aborts its simulation of this input.
WHAT N Step pattern shows that H^ <H^> is non-halting.
When embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ these steps would >>>>>> keep repeating:
Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
If that is what happens, then obviously H never aborted its
simulation, so it CAN'T.
As soon as embedded_H correctly recognizes this infinitely repeating
pattern in its correct simulation of N steps of its input it is
necessarily correct for it to report that that its simulated input
cannot possibly ever reach its halt state.
Only if it proved that it was correct if it does abort and go to
H.Qn, which it can't.
logical necessity.
(1) As soon as embedded_H correctly recognizes this infinitely
repeating pattern in its correct simulation of N steps of its input
Which makes the falicay of assuming there is a CORRECT pattern for H to detect in H^, and that H has the ability to detect it.
I have already shown that the pattern you claim in not correct if H can detect it.
More Fairy Dust powered Unicorns.
FAIL.
(2) it is necessarily correct for it to report that that its simulated
input cannot possibly ever reach its halt state.
Since (1) isn't established, (2) can't follow. FAIL.
On 1/25/22 12:27 AM, olcott wrote:
On 1/24/2022 11:15 PM, Richard Damon wrote:
On 1/25/22 12:04 AM, olcott wrote:
On 1/24/2022 10:54 PM, Richard Damon wrote:
On 1/24/22 11:28 PM, olcott wrote:
On 1/24/2022 10:25 PM, Richard Damon wrote:
On 1/24/22 11:19 PM, olcott wrote:
On 1/24/2022 10:16 PM, Richard Damon wrote:
On 1/24/22 10:58 PM, olcott wrote:
On 1/24/2022 9:50 PM, Richard Damon wrote:
On 1/24/22 10:45 PM, olcott wrote:
On 1/24/2022 8:26 PM, Richard Damon wrote:
On 1/24/22 9:11 PM, olcott wrote:
On 1/24/2022 8:03 PM, Richard Damon wrote:
On 1/24/22 8:32 PM, olcott wrote:
On 1/24/2022 6:50 PM, Richard Damon wrote:
On 1/24/22 7:09 PM, olcott wrote:
On 1/24/2022 5:49 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 1/24/22 10:03 AM, olcott wrote:
On 1/23/2022 10:45 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 1/23/22 11:17 PM, olcott wrote:
On 1/23/2022 9:57 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>
On 1/23/22 10:40 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 9:24 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 10:10 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 8:42 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 9:29 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 8:14 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
WARNING, you are getting way into hypothecctica >>>>>>>>>>>>>>>>>>>>>>> Unicoprn Terretory, but lets unpack this statement. >>>>>>>>>>>>>>>>>>>>>>>That isn't a 'stipulation', that is a DEFINITION. >>>>>>>>>>>>>>>>>>>>>>>>>On 1/23/22 9:03 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 7:55 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 8:10 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 7:00 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 7:25 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 6:09 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
Don't know what sort of logic you are >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> claiming.When testing whether or not one >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> assertion logically follows from another >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the premises are always "given" to be >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> true even if they are false. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>And you seem quite dense. I did NOT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> change the subject, I pointed out an >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> error in your statement. You seem to be >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unable to comprehend that. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>On 1/23/22 7:00 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 5:50 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 6:16 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 5:06 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 5:47 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 4:40 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 5:18 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 4:01 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 4:40 PM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 2:25 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 2:19 PM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 10:43 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 11:34 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 3:36 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 4:25 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 3:20 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is true for >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite loops, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite recursion, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely nested >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation and all >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> other non halting inputs: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever any >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input to any >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider would never >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach the final state >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of this simulated >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input in any finite >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> number of steps it is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always correct for the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider to abort its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation and >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> transition to its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reject state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can you PROVE that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> statement, or is this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just one of your false >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 'self evident truth'. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Anyone that knows that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> x86 language can tell >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its easy to match >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the infinite loop pattern: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> _Infinite_Loop() >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fa](01) 55 push ebp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fb](02) 8bec mov >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fd](02) ebfe jmp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 000015fd >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015ff](01) 5d pop ebp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001600](01) c3 ret >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0007) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001600] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fa][002126f0][002126f4]
You deliberate weasel words do not >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> apply to what I said: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>But reaching final state is the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same as Halting. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>55 push ebp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fb][002126f0][002126f4]
8bec mov ebp,esp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fd][002126f0][002126f4]
ebfe jmp 000015fd >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fd][002126f0][002126f4]
ebfe jmp 000015fd >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Showing that you can do >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> one case does not prove >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the same method >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> works on all, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> particularly harder methods. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is just you serving >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Red Herring. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And that pattern does NOT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> show up in the simulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by H of H^ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Which makes it MORE lies >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by Red Herring. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Total lack of proof. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does the proof include >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the posibility that the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input includes a copy >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the decider? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is always the case >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that a simulating halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider can correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> base its halt status >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decision on the behavior >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pure simulation of its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> LIE. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Proven incorrect. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H -> H.Qn then H^ -> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^.Qn and Halts and for >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^ <H^> proves H wrong. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We know that this must >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be true because we know >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the pure UTM >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of an Turing >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Machine description is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> defined to have >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> equivalent behavior to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that of the direct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution of the same >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, but that does't >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove what you sy. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are just LYING out of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your POOP. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The problem is that IF >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulating halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider does abort its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input based on some >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> condition, then it is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> no longer a source of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> truth for the halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> status of that input. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is not answering the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question: Does the input >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> stop running? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU need to answer, which >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H are you using? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H doesn't abort, then >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^ is non-halting, but H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will never answer. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H does abort and go to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H.Qn, then the pure >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the input >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WILL halt at H^.Qn, so H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> was wrong. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is answering the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Would the pure >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the input >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ever stop running? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, and if H -> H.Qn >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it will. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU JUST AREN'T BRIGHT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ENOUGH TO GET THIS. IT CAN >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> BE VERIFIED AS COMPLETELY >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> TRUE ENTIRELY ON THE BASIS >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> OF THE MEANING OF ITS WORDS. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is the case that if >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H recognizes an >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely repeating >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern in the simulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input such that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this correctly simulated >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final state then >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this is complete prove >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that this simulated input >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never halts. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If it COULD CORRECTLY >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recognize an infinitely >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeating pattern in its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation that can not >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its final >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state (when simulated by a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM, not just H) then, YES, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H can go to H.Qn. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The problem is that due to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 'pathological >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-reference' in H^, ANY >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern that H sees in its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of <H^> <H^> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it transitions to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H.Qn, will BY DEFINITION, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> become a halting pattern. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So a correctly simulated >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT that cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final state >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches its final state >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> anyway. YOU ARE DUMBER THAN >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A BOX OF ROCKS !!! >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That's not what I said, I >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> said there is no pattern that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H use to detect that it won't >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt, as any pattern that H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> uses to decide to go to H.Qn >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will be WRONG for H^ as if H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> goes to H.Qn, then H^ also >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> goes to H^.Qn and Halts. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When the correctly simulated >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT to embedded_H cannot >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its final state >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it is necessarily correct for >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H to report that its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated INPUT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly reach its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, but you have only >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proved that H^ is non-halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for the case where H doesn't >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because you are dumber than a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> box of rocks (or perhaps you are >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a bot?) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You did not notice that I never >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mentioned the word: "halting". >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For a human being you are much >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dumber than a box of rocks. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For a bot you did quite well >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (you nearly passed the Turing >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> test) it took me this long to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> realize that you are not a human >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> being. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You have only prove that the pure >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the input to H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never reaches a final state for >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> case when H doesn't abort its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
(1) Premise: When the correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT to embedded_H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly reach its final state >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
(2) Conclusion: It is necessarily >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct for embedded_H to report >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its correctly simulated INPUT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly reach its final >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
And the correct simulation of the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H is determined by the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM, not H. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
(2) is a logical consequence of (1). >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is logically incorrect to argue >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> with a deductive logical premise. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
But 1 is only true if H doesn't go to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H.Qn, so H can't correctly go to H.Qn. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You are quite the deceiver making sure >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to always change the subject rather >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> than directly address the point at hand. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
But 1 ISN'T True if H <H^> <H^> -> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H.Qn, as the correctly simulate input >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
(2) logically follows from (1) is true. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
And arguemnt with a false premise is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unsound.
We are not yet looking at soundness we are >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> looking at validity. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is true that (2) logically follows from >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1).
We can't move on from this one point until >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> we have mutual agreement. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Very strange then, why are you arguing >>>>>>>>>>>>>>>>>>>>>>>>>>>>> about that which was accepted unless you >>>>>>>>>>>>>>>>>>>>>>>>>>>>> disagree to the conditions that they were >>>>>>>>>>>>>>>>>>>>>>>>>>>>> accepted under?
It has long been accepted that the under >>>>>>>>>>>>>>>>>>>>>>>>>>>>> the hypothetical condition where H can >>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually determine that the UTM will run >>>>>>>>>>>>>>>>>>>>>>>>>>>>> forever, it is correct (and in fact needed >>>>>>>>>>>>>>>>>>>>>>>>>>>>> to be correct) for H to go to H.Qn and say >>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
OKAY so then you agree with this? >>>>>>>>>>>>>>>>>>>>>>>>>>>>
(1) Premise: When the correctly simulated >>>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT to embedded_H
cannot possibly reach its final state >>>>>>>>>>>>>>>>>>>>>>>>>>>>
(2) Conclusion: It is necessarily correct >>>>>>>>>>>>>>>>>>>>>>>>>>>> for embedded_H to
report that its correctly simulated INPUT >>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly
reach its final state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
Under the definition that 'correctly >>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input' is as determined by a UTM, >>>>>>>>>>>>>>>>>>>>>>>>>>> not H (if it aborts its simulation). >>>>>>>>>>>>>>>>>>>>>>>>>>>
It is only stipulated to be correct other >>>>>>>>>>>>>>>>>>>>>>>>>> details are currently unspecified. >>>>>>>>>>>>>>>>>>>>>>>>>
This is obviously your attempt at being a weasel. >>>>>>>>>>>>>>>>>>>>>>>>>
The DEFINITION of correct simulation is the >>>>>>>>>>>>>>>>>>>>>>>>> results of a UTM simulating the input. >>>>>>>>>>>>>>>>>>>>>>>>>
Any deviaiton in this means you are just eating >>>>>>>>>>>>>>>>>>>>>>>>> your POOP.
It also does not presume that H CAN determine >>>>>>>>>>>>>>>>>>>>>>>>>>> that this condition exists, so it would be >>>>>>>>>>>>>>>>>>>>>>>>>>> correct, but H might not be able to decide to >>>>>>>>>>>>>>>>>>>>>>>>>>> do so. So it may be correct for it to do so, >>>>>>>>>>>>>>>>>>>>>>>>>>> but it might not actually be able to do it. >>>>>>>>>>>>>>>>>>>>>>>>>>>
There is also the case you tend to ignore >>>>>>>>>>>>>>>>>>>>>>>>>>> that you start with an H that is defined to >>>>>>>>>>>>>>>>>>>>>>>>>>> NOT abort, but you try to use (2) to claim >>>>>>>>>>>>>>>>>>>>>>>>>>> that it now can abort, the H is (2) must be >>>>>>>>>>>>>>>>>>>>>>>>>>> the same H that the H^ in (1) was built form >>>>>>>>>>>>>>>>>>>>>>>>>>>
All of these restrictions are actually in the >>>>>>>>>>>>>>>>>>>>>>>>>>> actual meaning of the words you are using, >>>>>>>>>>>>>>>>>>>>>>>>>>> from the context of the problem, but I state >>>>>>>>>>>>>>>>>>>>>>>>>>> them because knowing you, you are going to >>>>>>>>>>>>>>>>>>>>>>>>>>> try to break that restrictions. >>>>>>>>>>>>>>>>>>>>>>>>>>>
This seems to be the very first time that you >>>>>>>>>>>>>>>>>>>>>>>>>> actually paid close attention, good jo >>>>>>>>>>>>>>>>>>>>>>>>>>
As I asked, how is that different from the >>>>>>>>>>>>>>>>>>>>>>>>>>> statement of the requirements on H? >>>>>>>>>>>>>>>>>>>>>>>>>>>
We define Linz H to base its halt status >>>>>>>>>>>>>>>>>>>>>>>>>> decision on the behavior of its pure >>>>>>>>>>>>>>>>>>>>>>>>>> simulation of N steps of its input. N is >>>>>>>>>>>>>>>>>>>>>>>>>> either the number of steps that it takes for >>>>>>>>>>>>>>>>>>>>>>>>>> its simulated input to reach its final state >>>>>>>>>>>>>>>>>>>>>>>>>> or the number of steps required for H to match >>>>>>>>>>>>>>>>>>>>>>>>>> an infinite behavior pattern proving that its >>>>>>>>>>>>>>>>>>>>>>>>>> simulated input would never reach its own >>>>>>>>>>>>>>>>>>>>>>>>>> final state. In this case H aborts the >>>>>>>>>>>>>>>>>>>>>>>>>> simulation of this input and transitions to H.qn. >>>>>>>>>>>>>>>>>>>>>>>>>>
Note, The correct answer is NOT based on a >>>>>>>>>>>>>>>>>>>>>>>>> simulation of N steps, but a simulation by a >>>>>>>>>>>>>>>>>>>>>>>>> UTM which will run until it halts. >>>>>>>>>>>>>>>>>>>>>>>>>
H needs to make ITS decision on the limited N >>>>>>>>>>>>>>>>>>>>>>>>> step, so it needs to prove that its answer >>>>>>>>>>>>>>>>>>>>>>>>> matches.
Remember, when we do this run, H is defined, >>>>>>>>>>>>>>>>>>>>>>>>> and thus N is a SPECIFIC number, not an >>>>>>>>>>>>>>>>>>>>>>>>> 'arbitrary' number.
You also will need to some how prove that a >>>>>>>>>>>>>>>>>>>>>>>>> pattern exists in N steps that correct dectect >>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
This has been previously shown to be >>>>>>>>>>>>>>>>>>>>>>>>> impossible, so you need to actually come up >>>>>>>>>>>>>>>>>>>>>>>>> with it or show an actual error in the proof. >>>>>>>>>>>>>>>>>>>>>>>>> You can't just assume it exists. >>>>>>>>>>>>>>>>>>>>>>>>>
Great we can move to the next step: >>>>>>>>>>>>>>>>>>>>>>>>
(1) Premise: When embedded_H correctly >>>>>>>>>>>>>>>>>>>>>>>> determines its simulated INPUT to >>>>>>>>>>>>>>>>>>>>>>>> embedded_H cannot possibly reach its final state >>>>>>>>>>>>>>>>>>>>>>>>
(2) Conclusion: It is necessarily correct for >>>>>>>>>>>>>>>>>>>>>>>> embedded_H to report that its correctly >>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT cannot possibly reach its final >>>>>>>>>>>>>>>>>>>>>>>> state.
IF H can correctly deteremine (that means that >>>>>>>>>>>>>>>>>>>>>>> there needs to exist a finite algroithm to >>>>>>>>>>>>>>>>>>>>>>> determine this case, and that this result matches >>>>>>>>>>>>>>>>>>>>>>> the behavior demonstrated by the definitional UTM >>>>>>>>>>>>>>>>>>>>>>> simulataion of this input), that the input will >>>>>>>>>>>>>>>>>>>>>>> NEVER reach it final state,
Then yes, it is correct for H to report that its >>>>>>>>>>>>>>>>>>>>>>> input can not possible reach its final state. >>>>>>>>>>>>>>>>>>>>>>>
Great we have finally begun an honest dialogue. >>>>>>>>>>>>>>>>>>>>>>
Note, that if H does this, then the proof that >>>>>>>>>>>>>>>>>>>>>>> the input never reached its final state must have >>>>>>>>>>>>>>>>>>>>>>> included that fact that the copy of H inside H^ >>>>>>>>>>>>>>>>>>>>>>> will also do the exact same thing with the exact >>>>>>>>>>>>>>>>>>>>>>> same input.
Also, to show the premise is True, you need to be >>>>>>>>>>>>>>>>>>>>>>> able to PROVE or actually provide the exact >>>>>>>>>>>>>>>>>>>>>>> finite algorithm that it used to detemine this fact.
On 1/25/22 9:44 AM, olcott wrote:
On 1/25/2022 5:55 AM, Richard Damon wrote:
On 1/25/22 12:27 AM, olcott wrote:
On 1/24/2022 11:15 PM, Richard Damon wrote:
On 1/25/22 12:04 AM, olcott wrote:
On 1/24/2022 10:54 PM, Richard Damon wrote:
On 1/24/22 11:28 PM, olcott wrote:
On 1/24/2022 10:25 PM, Richard Damon wrote:
On 1/24/22 11:19 PM, olcott wrote:
On 1/24/2022 10:16 PM, Richard Damon wrote:
On 1/24/22 10:58 PM, olcott wrote:
On 1/24/2022 9:50 PM, Richard Damon wrote:
On 1/24/22 10:45 PM, olcott wrote:
On 1/24/2022 8:26 PM, Richard Damon wrote:
On 1/24/22 9:11 PM, olcott wrote:
On 1/24/2022 8:03 PM, Richard Damon wrote:
On 1/24/22 8:32 PM, olcott wrote:
On 1/24/2022 6:50 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 1/24/22 7:09 PM, olcott wrote:
On 1/24/2022 5:49 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 1/24/22 10:03 AM, olcott wrote:
On 1/23/2022 10:45 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 11:17 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 9:57 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>
On 1/23/22 10:40 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 9:24 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 10:10 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 8:42 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 9:29 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 8:14 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
That isn't a 'stipulation', that is a >>>>>>>>>>>>>>>>>>>>>>>>>>> DEFINITION.On 1/23/22 9:03 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 7:55 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 8:10 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 7:00 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
On 1/23/22 7:25 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 6:09 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 7:00 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 5:50 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 6:16 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 5:06 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 5:47 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 4:40 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 5:18 PM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 4:01 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 4:40 PM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 2:25 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 2:19 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 10:43 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 11:34 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 3:36 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 4:25 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 3:20 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is true for >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite loops, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite recursion, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely nested >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation and all >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> other non halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever any >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any simulating halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider would never >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach the final >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state of this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input in >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any finite number of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps it is always >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct for the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider to abort its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation and >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> transition to its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reject state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can you PROVE that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> statement, or is this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just one of your >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> false 'self evident >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> truth'. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Anyone that knows that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> x86 language can tell >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its easy to match >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the infinite loop >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> _Infinite_Loop() >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fa](01) 55 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fb](02) 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fd](02) ebfe >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> jmp 000015fd >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015ff](01) 5d pop >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001600](01) c3 ret >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0007) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001600] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fa][002126f0][002126f4]When testing whether or not one >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> assertion logically follows from >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> another the premises are always >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "given" to be true even if they are >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> false.
And you seem quite dense. I did NOT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> change the subject, I pointed out an >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> error in your statement. You seem to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be unable to comprehend that. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>And the correct simulation of the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H is determined by the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM, not H. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>55 push ebp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fb][002126f0][002126f4]
8bec mov ebp,esp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fd][002126f0][002126f4]
ebfe jmp 000015fd >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fd][002126f0][002126f4]
ebfe jmp 000015fd >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Showing that you can do >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> one case does not prove >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the same method >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> works on all, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> particularly harder >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> methods. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is just you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> serving Red Herring. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And that pattern does >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> NOT show up in the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation by H of H^ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Which makes it MORE >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> lies by Red Herring. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Total lack of proof. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does the proof >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> include the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> posibility that the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input includes a copy >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the decider? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is always the case >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that a simulating halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider can correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> base its halt status >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decision on the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pure >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> LIE. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Proven incorrect. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H -> H.Qn then H^ -> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^.Qn and Halts and for >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^ <H^> proves H wrong. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We know that this must >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be true because we >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> know that the pure UTM >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of an >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Turing Machine >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> description is defined >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to have equivalent >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior to that of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the direct execution >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the same machine >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, but that does't >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove what you sy. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are just LYING out >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of your POOP. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The problem is that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IF the simulating >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider does >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its input based >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on some condition, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then it is no longer >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a source of truth for >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the halting status of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that input. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is not answering >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the question: Does the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input stop running? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU need to answer, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> which H are you using? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H doesn't abort, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then H^ is non-halting, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but H will never answer. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H does abort and go >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H.Qn, then the pure >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the input >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WILL halt at H^.Qn, so >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H was wrong. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is answering the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Would the pure >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input ever stop running? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, and if H -> H.Qn >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it will. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU JUST AREN'T BRIGHT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ENOUGH TO GET THIS. IT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> CAN BE VERIFIED AS >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> COMPLETELY TRUE ENTIRELY >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ON THE BASIS OF THE >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> MEANING OF ITS WORDS. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is the case that if >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H recognizes an >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely repeating >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern in the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> such that this correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input cannot >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its final >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state then this is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete prove that this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input never >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If it COULD CORRECTLY >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recognize an infinitely >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeating pattern in its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation that can not >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its final >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state (when simulated by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a UTM, not just H) then, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YES, H can go to H.Qn. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The problem is that due >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to 'pathological >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-reference' in H^, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ANY pattern that H sees >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in its simulation of <H^> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <H^> that it transitions >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H.Qn, will BY >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DEFINITION, become a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting pattern. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So a correctly simulated >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT that cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final state >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches its final state >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> anyway. YOU ARE DUMBER >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THAN A BOX OF ROCKS !!! >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That's not what I said, I >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> said there is no pattern >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H use to detect that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it won't halt, as any >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern that H uses to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decide to go to H.Qn will >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be WRONG for H^ as if H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> goes to H.Qn, then H^ also >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> goes to H^.Qn and Halts. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When the correctly simulated >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT to embedded_H cannot >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its final >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state it is necessarily >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct for embedded_H to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report that its correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT cannot >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its final state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, but you have only >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proved that H^ is non-halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for the case where H doesn't >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because you are dumber than a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> box of rocks (or perhaps you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are a bot?) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You did not notice that I >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never mentioned the word: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "halting". >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For a human being you are much >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dumber than a box of rocks. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For a bot you did quite well >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (you nearly passed the Turing >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> test) it took me this long to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> realize that you are not a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> human being. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But reaching final state is the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same as Halting. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have only prove that the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pure simulation of the input to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H never reaches a final state >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for case when H doesn't abort >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You deliberate weasel words do >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not apply to what I said: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Premise: When the correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT to embedded_H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly reach its final >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) Conclusion: It is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct for >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H to report that its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated INPUT cannot >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its final state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
(2) is a logical consequence of (1). >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is logically incorrect to argue >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> with a deductive logical premise. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
But 1 is only true if H doesn't go >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H.Qn, so H can't correctly go to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H.Qn. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You are quite the deceiver making >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sure to always change the subject >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> rather than directly address the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> point at hand. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
But 1 ISN'T True if H <H^> <H^> -> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H.Qn, as the correctly simulate input >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
(2) logically follows from (1) is true. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Don't know what sort of logic you are >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> claiming.
And arguemnt with a false premise is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unsound.
We are not yet looking at soundness we >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are looking at validity. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is true that (2) logically follows >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from (1).
We can't move on from this one point >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> until we have mutual agreement. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Very strange then, why are you arguing >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about that which was accepted unless you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disagree to the conditions that they were >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> accepted under?
It has long been accepted that the under >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the hypothetical condition where H can >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually determine that the UTM will run >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> forever, it is correct (and in fact >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> needed to be correct) for H to go to H.Qn >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and say non-halting. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
OKAY so then you agree with this? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
(1) Premise: When the correctly simulated >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT to embedded_H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly reach its final state >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
(2) Conclusion: It is necessarily correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for embedded_H to
report that its correctly simulated INPUT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly
reach its final state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Under the definition that 'correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input' is as determined by a UTM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>> not H (if it aborts its simulation). >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
It is only stipulated to be correct other >>>>>>>>>>>>>>>>>>>>>>>>>>>> details are currently unspecified. >>>>>>>>>>>>>>>>>>>>>>>>>>>
This is obviously your attempt at being a >>>>>>>>>>>>>>>>>>>>>>>>>>> weasel.
The DEFINITION of correct simulation is the >>>>>>>>>>>>>>>>>>>>>>>>>>> results of a UTM simulating the input. >>>>>>>>>>>>>>>>>>>>>>>>>>>
Any deviaiton in this means you are just >>>>>>>>>>>>>>>>>>>>>>>>>>> eating your POOP.
It also does not presume that H CAN >>>>>>>>>>>>>>>>>>>>>>>>>>>>> determine that this condition exists, so it >>>>>>>>>>>>>>>>>>>>>>>>>>>>> would be correct, but H might not be able >>>>>>>>>>>>>>>>>>>>>>>>>>>>> to decide to do so. So it may be correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>> for it to do so, but it might not actually >>>>>>>>>>>>>>>>>>>>>>>>>>>>> be able to do it.
There is also the case you tend to ignore >>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you start with an H that is defined to >>>>>>>>>>>>>>>>>>>>>>>>>>>>> NOT abort, but you try to use (2) to claim >>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it now can abort, the H is (2) must be >>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same H that the H^ in (1) was built form >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
All of these restrictions are actually in >>>>>>>>>>>>>>>>>>>>>>>>>>>>> the actual meaning of the words you are >>>>>>>>>>>>>>>>>>>>>>>>>>>>> using, from the context of the problem, but >>>>>>>>>>>>>>>>>>>>>>>>>>>>> I state them because knowing you, you are >>>>>>>>>>>>>>>>>>>>>>>>>>>>> going to try to break that restrictions. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
This seems to be the very first time that >>>>>>>>>>>>>>>>>>>>>>>>>>>> you actually paid close attention, good jo >>>>>>>>>>>>>>>>>>>>>>>>>>>>
As I asked, how is that different from the >>>>>>>>>>>>>>>>>>>>>>>>>>>>> statement of the requirements on H? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
We define Linz H to base its halt status >>>>>>>>>>>>>>>>>>>>>>>>>>>> decision on the behavior of its pure >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of N steps of its input. N is >>>>>>>>>>>>>>>>>>>>>>>>>>>> either the number of steps that it takes for >>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulated input to reach its final state >>>>>>>>>>>>>>>>>>>>>>>>>>>> or the number of steps required for H to >>>>>>>>>>>>>>>>>>>>>>>>>>>> match an infinite behavior pattern proving >>>>>>>>>>>>>>>>>>>>>>>>>>>> that its simulated input would never reach >>>>>>>>>>>>>>>>>>>>>>>>>>>> its own final state. In this case H aborts >>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation of this input and transitions >>>>>>>>>>>>>>>>>>>>>>>>>>>> to H.qn.
Note, The correct answer is NOT based on a >>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of N steps, but a simulation by a >>>>>>>>>>>>>>>>>>>>>>>>>>> UTM which will run until it halts. >>>>>>>>>>>>>>>>>>>>>>>>>>>
H needs to make ITS decision on the limited N >>>>>>>>>>>>>>>>>>>>>>>>>>> step, so it needs to prove that its answer >>>>>>>>>>>>>>>>>>>>>>>>>>> matches.
Remember, when we do this run, H is defined, >>>>>>>>>>>>>>>>>>>>>>>>>>> and thus N is a SPECIFIC number, not an >>>>>>>>>>>>>>>>>>>>>>>>>>> 'arbitrary' number.
You also will need to some how prove that a >>>>>>>>>>>>>>>>>>>>>>>>>>> pattern exists in N steps that correct >>>>>>>>>>>>>>>>>>>>>>>>>>> dectect non-halting.
This has been previously shown to be >>>>>>>>>>>>>>>>>>>>>>>>>>> impossible, so you need to actually come up >>>>>>>>>>>>>>>>>>>>>>>>>>> with it or show an actual error in the proof.
On 1/25/22 7:03 PM, olcott wrote:
On 1/25/2022 5:43 PM, Richard Damon wrote:
On 1/25/22 9:44 AM, olcott wrote:
On 1/25/2022 5:55 AM, Richard Damon wrote:
On 1/25/22 12:27 AM, olcott wrote:
On 1/24/2022 11:15 PM, Richard Damon wrote:
On 1/25/22 12:04 AM, olcott wrote:
On 1/24/2022 10:54 PM, Richard Damon wrote:
On 1/24/22 11:28 PM, olcott wrote:
On 1/24/2022 10:25 PM, Richard Damon wrote:
On 1/24/22 11:19 PM, olcott wrote:
On 1/24/2022 10:16 PM, Richard Damon wrote:
On 1/24/22 10:58 PM, olcott wrote:
On 1/24/2022 9:50 PM, Richard Damon wrote:
On 1/24/22 10:45 PM, olcott wrote:
On 1/24/2022 8:26 PM, Richard Damon wrote:
On 1/24/22 9:11 PM, olcott wrote:
On 1/24/2022 8:03 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>
On 1/24/22 8:32 PM, olcott wrote:
On 1/24/2022 6:50 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 1/24/22 7:09 PM, olcott wrote:
On 1/24/2022 5:49 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 1/24/22 10:03 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 10:45 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 11:17 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 9:57 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>
On 1/23/22 10:40 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 9:24 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 10:10 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 8:42 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 9:29 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 8:14 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
That isn't a 'stipulation', that is a >>>>>>>>>>>>>>>>>>>>>>>>>>>>> DEFINITION.On 1/23/22 9:03 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 7:55 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
On 1/23/22 8:10 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 7:00 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 7:25 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 6:09 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 7:00 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 5:50 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 6:16 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 5:06 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 5:47 PM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 4:40 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 5:18 PM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 4:01 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 4:40 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 2:25 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 2:19 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 10:43 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 11:34 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 3:36 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 4:25 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 3:20 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is true for >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite loops, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursion, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely nested >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation and all >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> other non halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever any >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any simulating >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider would >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never reach the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this simulated >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input in any >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite number of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps it is always >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct for the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider to abort >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation and >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> transition to its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reject state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can you PROVE that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> statement, or is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this just one of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your false 'self >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> evident truth'. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Anyone that knows >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that x86 language >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can tell that its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> easy to match the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite loop pattern: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> _Infinite_Loop() >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fa](01) 55 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fb](02) 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fd](02) ebfe >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> jmp 000015fd >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015ff](01) 5d >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pop ebp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001600](01) c3 ret >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0007) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001600] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fa][002126f0][002126f4]
When testing whether or not one >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> assertion logically follows from >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> another the premises are always >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "given" to be true even if they are >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> false.And you seem quite dense. I did NOT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> change the subject, I pointed out >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an error in your statement. You >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> seem to be unable to comprehend that. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>But 1 is only true if H doesn't >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> go to H.Qn, so H can't correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> go to H.Qn. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>55 push ebp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fb][002126f0][002126f4]
8bec mov ebp,esp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fd][002126f0][002126f4]
ebfe jmp 000015fd >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fd][002126f0][002126f4]
ebfe jmp 000015fd >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Showing that you can >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do one case does not >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove that the same >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> method works on all, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> particularly harder >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> methods. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is just you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> serving Red Herring. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And that pattern does >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> NOT show up in the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation by H of H^ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Which makes it MORE >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> lies by Red Herring. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Total lack of proof. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does the proof >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> include the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> posibility that the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input includes a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> copy of the decider? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is always the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> case that a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider can >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly base its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt status decision >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on the behavior pure >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> LIE. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Proven incorrect. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H -> H.Qn then H^ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> -> H^.Qn and Halts >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and for H^ <H^> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proves H wrong. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We know that this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must be true because >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> we know that the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pure UTM simulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of an Turing Machine >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> description is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> defined to have >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> equivalent behavior >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to that of the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> direct execution of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same machine >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, but that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does't prove what you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sy. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are just LYING >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> out of your POOP. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The problem is that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IF the simulating >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider does >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its input >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> based on some >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> condition, then it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is no longer a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> source of truth for >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the halting status >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of that input. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is not answering >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the question: Does >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input stop running? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU need to answer, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> which H are you using? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H doesn't abort, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then H^ is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting, but H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will never answer. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H does abort and >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> go to H.Qn, then the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pure simulation of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input WILL halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> at H^.Qn, so H was >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is answering the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Would the pure >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input ever stop >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, and if H -> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H.Qn it will. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU JUST AREN'T BRIGHT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ENOUGH TO GET THIS. IT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> CAN BE VERIFIED AS >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> COMPLETELY TRUE >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ENTIRELY ON THE BASIS >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> OF THE MEANING OF ITS >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WORDS. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is the case that if >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H recognizes >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an infinitely >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeating pattern in >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation of its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input such that this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final state >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then this is complete >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove that this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input never >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If it COULD CORRECTLY >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recognize an >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely repeating >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern in its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation that can not >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state (when >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by a UTM, not >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just H) then, YES, H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can go to H.Qn. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The problem is that due >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to 'pathological >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-reference' in H^, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ANY pattern that H sees >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in its simulation of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <H^> <H^> that it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> transitions to H.Qn, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will BY DEFINITION, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> become a halting pattern. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So a correctly simulated >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT that cannot >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its final >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state reaches its final >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state anyway. YOU ARE >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DUMBER THAN A BOX OF >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ROCKS !!! >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That's not what I said, I >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> said there is no pattern >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H use to detect that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it won't halt, as any >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern that H uses to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decide to go to H.Qn will >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be WRONG for H^ as if H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> goes to H.Qn, then H^ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> also goes to H^.Qn and >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halts. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When the correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final state it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is necessarily correct for >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H to report that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its correctly simulated >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, but you have only >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proved that H^ is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting for the case >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> where H doesn't abort its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because you are dumber than >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a box of rocks (or perhaps >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are a bot?) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You did not notice that I >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never mentioned the word: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "halting". >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For a human being you are >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> much dumber than a box of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> rocks. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For a bot you did quite well >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (you nearly passed the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Turing test) it took me this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> long to realize that you are >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not a human being. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But reaching final state is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same as Halting. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have only prove that the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pure simulation of the input >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H never reaches a final >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state for case when H doesn't >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You deliberate weasel words do >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not apply to what I said: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Premise: When the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated INPUT to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final state >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) Conclusion: It is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct for >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H to report that its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated INPUT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly reach its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And the correct simulation of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input to H is determined by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the UTM, not H. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) is a logical consequence of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1). >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is logically incorrect to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> argue with a deductive logical >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> premise. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You are quite the deceiver making >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sure to always change the subject >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> rather than directly address the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> point at hand. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
But 1 ISN'T True if H <H^> <H^> -> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H.Qn, as the correctly simulate input >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
(2) logically follows from (1) is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> true. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Don't know what sort of logic you are >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> claiming. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
And arguemnt with a false premise is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unsound. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
We are not yet looking at soundness we >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are looking at validity. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is true that (2) logically follows >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from (1).
We can't move on from this one point >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> until we have mutual agreement. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Very strange then, why are you arguing >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about that which was accepted unless >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you disagree to the conditions that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> they were accepted under? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
It has long been accepted that the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> under the hypothetical condition where >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H can actually determine that the UTM >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will run forever, it is correct (and in >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fact needed to be correct) for H to go >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H.Qn and say non-halting. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
OKAY so then you agree with this? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
(1) Premise: When the correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT to embedded_H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly reach its final state >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
(2) Conclusion: It is necessarily >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct for embedded_H to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report that its correctly simulated >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Under the definition that 'correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input' is as determined by a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM, not H (if it aborts its simulation). >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
It is only stipulated to be correct other >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> details are currently unspecified. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
This is obviously your attempt at being a >>>>>>>>>>>>>>>>>>>>>>>>>>>>> weasel.
The DEFINITION of correct simulation is the >>>>>>>>>>>>>>>>>>>>>>>>>>>>> results of a UTM simulating the input. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Any deviaiton in this means you are just >>>>>>>>>>>>>>>>>>>>>>>>>>>>> eating your POOP.
It also does not presume that H CAN >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determine that this condition exists, so >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it would be correct, but H might not be >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> able to decide to do so. So it may be >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct for it to do so, but it might not >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually be able to do it. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
There is also the case you tend to ignore >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you start with an H that is defined >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to NOT abort, but you try to use (2) to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> claim that it now can abort, the H is (2) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must be the same H that the H^ in (1) was >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> built form
All of these restrictions are actually in >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the actual meaning of the words you are >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> using, from the context of the problem, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but I state them because knowing you, you
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 297 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 109:52:02 |
| Calls: | 6,662 |
| Files: | 12,209 |
| Messages: | 5,335,727 |