olcott <NoOne@NoWhere.com> writes:
On 4/14/2022 3:28 PM, Ben wrote:
olcott <NoOne@NoWhere.com> writes:
As long as the correctly simulated input to H(P,P) would never halt
then we know it is non-halting.
Readers beware! Ask yourselves why PO does not say the simpler "never
halts", but instead says "/would/ never halt". Why the implied
subjunctive mood?
A simulating halt decider must correctly predict the future behavior
of of its simulated input.
But that's not what the implied subjunctive is about. We know what it's about because you've been clear in the past. You need to justify the
wrong answer (false) for a halting computation.
olcott <NoOne@NoWhere.com> writes:
On 4/14/2022 3:54 PM, Ben wrote:
olcott <NoOne@NoWhere.com> writes:
On 4/14/2022 11:40 AM, Ben wrote:
olcott <NoOne@NoWhere.com> writes:
On 4/14/2022 9:30 AM, Ben wrote:Just use the right terms. H(P,P) has not input. The call has
olcott <NoOne@NoWhere.com> writes:
On 4/13/2022 6:02 PM, Ben wrote:Being generous, the "input" to H in the call H(P,P) is just two
olcott <NoOne@NoWhere.com> writes:
On 4/13/2022 2:38 PM, Ben wrote:
olcott <NoOne@NoWhere.com> writes:
When mere rhetoric goes against easily verified facts rhetoric loses:The simulated input to H(P,P) is non halting.
Then you are either (a) doing it wrong, or (b) wrong to have said that
P(P) halts. Oh, there is a third (c) you are using poetic license, and
simulating the input means something silly. It's literal nonsense to
there's a lot of scope for you make up some silly meaning. >>>>>>>>>>
Your own claim: H(P,P) == false is "correct" even though P(P) halts. >>>>>>>>> That's not rhetoric. You've been too clear about this attempt. You >>>>>>>>> need to try a new ruse.
Because the input to H(P,P) is non-halting then nothing in the >>>>>>>> universe can possibly contradict the fact that it is non-halting. >>>>>>>
pointers. They are neither halting nor non-halting -- they are just >>>>>>> pointers.
Up until, now I was prepared to take your words metaphorically, but >>>>>>> since you duck the key question of what "the input to H(P,P) is
non-halting" means,
Sure when I make to to explain ever details many hundreds of times >>>>>> damned liars will say that I never mentioned any of this.
arguments. They are just pointers. Pointers are not halting nor are >>>>> they non halting. Given that this mantra is the core of what you are >>>>> now claiming, I would have thought you would want to avoid it being
patentent nonsense.
The input to H is the only way that finite strings can be passed to a >>>>>> "C" function and points to the finite string of the machine code of P. >>>>> H has no input. Do you mean the two pointer arguments?
The simulating halt decider H uses an x86 emulator to simulate its >>>>>> input (P,P) and finds that it would never reach its own final state in >>>>>> an unlimited number of simulated steps.
(P,P) is too vague. What needs to be simulated is the first pointer >>>>> being called as a function with the second as it's argument. I.e. the >>>>> call P(P) is what should be simulated.
That the correctly simulated input to H(P,P) cannot possibly reach its >>>> own final state proves that this input is not-halting.
Adding all of the tedious details that you suggest does not change
this fact.
If you add all the corrections, sorry, "tedious details", it contradicts >>> what you've said in the past. With the errors left in place, the naive
reader won't knowing exactly what's being said -- and I think that's
deliberate.
For example, why talk about simulation at all since simulations of
computations halt or don't halt if and only if the computations do
themselves? Well, it adds yet another puff of smoke to the mirrors
you've got in there already like what that "its" refers to (since
nothing here has a final state), or what non-halting pointers are.
"The input to H(P,P)" should mean the two pointers, P and P. Simulating >>> them should mean simulating the call P(P) and the simulation "not
reaching its own final state" should mean that the simulation of P(P)
does not halt. And that happens if, and only if, the call P(P) itself
does not halt.
I honestly have no idea if that is what you mean, but if it is, it's
wrong because P(P) halts. You are probably just trying to cover that
up.
That a non input halts, converts the world to Fascism or opens a very
popular brothel is totally unrelated to the easily confirmed fact that
the input to H(P,P)* does not halt.
The correct value of H(P,P) is determined by the halting status of what
you call a non input:
On Wednesday, April 13, 2022 at 11:40:55 PM UTC-4, olcott wrote:
On 4/13/2022 10:33 PM, Dennis Bush wrote:
On Wednesday, April 13, 2022 at 11:27:49 PM UTC-4, olcott wrote:ONE OF THESE ASSUMPTIONS MUST BE INCORRECT* BECAUSE IT CONTRADICTS
On 4/13/2022 10:16 PM, Dennis Bush wrote:
On Wednesday, April 13, 2022 at 11:14:05 PM UTC-4, olcott wrote:
On 4/13/2022 10:09 PM, Dennis Bush wrote:
On Wednesday, April 13, 2022 at 11:08:02 PM UTC-4, olcott wrote: >>>>>>>> On 4/13/2022 10:03 PM, Dennis Bush wrote:I am not struggling with the fact that you are having fun being a liar. >>>>>>
On Wednesday, April 13, 2022 at 10:56:03 PM UTC-4, olcott wrote: >>>>>>>>>> On 4/13/2022 9:50 PM, Dennis Bush wrote:If an X is a Y and you deny it then you are a liar.
On Wednesday, April 13, 2022 at 10:48:25 PM UTC-4, olcott wrote: >>>>>>>>>>>> On 4/13/2022 9:36 PM, Dennis Bush wrote:Liar !
It is a verified fact that the input to H(P,P) is *halting* as follows:On Wednesday, April 13, 2022 at 10:34:37 PM UTC-4, olcott wrote: >>>>>>>>>>>>>> On 4/13/2022 9:32 PM, Dennis Bush wrote:It is a verified fact that the input to H(P,P) is non-halting and Dennis
Still no explanation.On Wednesday, April 13, 2022 at 10:28:54 PM UTC-4, olcott wrote:
On 4/13/2022 9:14 PM, Dennis Bush wrote:
On Wednesday, April 13, 2022 at 10:06:03 PM UTC-4, olcott wrote:Liar
On 4/13/2022 6:45 AM, Dennis Bush wrote:
On Tuesday, April 12, 2022 at 11:35:34 PM UTC-4, olcott wrote:Because the input to H(P,P) is non-halting
On 4/12/2022 10:25 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>> On Tuesday, April 12, 2022 at 11:23:46 PM UTC-4, olcott wrote:
That H(P,P)==false is correct is true by logical necessity.On 4/12/2022 10:20 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>> On Tuesday, April 12, 2022 at 11:17:52 PM UTC-4, olcott wrote:
You are trying to prove that Bill Smith is not guilty because Bill JonesOn 4/12/2022 10:15 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, April 12, 2022 at 11:09:11 PM UTC-4, olcott wrote:Translation:
I can see that you don't want this dialogue to continue.On 4/12/2022 10:05 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, April 12, 2022 at 10:59:47 PM UTC-4, olcott wrote:
Hb(P,P) is off topic because it proves nothing and you know that itOn 4/12/2022 9:56 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, April 12, 2022 at 10:53:05 PM UTC-4, olcott wrote:
A dishonest attempt at the strawman fallacy. >>>>>>>>>>>>>>>>>>>>>>>>>>>>On 4/12/2022 9:13 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, April 12, 2022 at 10:06:02 PM UTC-4, olcott wrote:And when Hb simulates this input, it reaches a final state. Therefore H is wrong to report non-halting.
The simulated input to H(P,P) cannot possibly reach its own final stateOn 4/12/2022 9:02 PM, Ben wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>As a matter of fact it does. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
We know [by definition] that a correctly simulated input that wouldOn 4/12/2022 7:49 PM, Ben wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>WHOOP! WHOOP! WHOOP! Danger Will Robinson. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
On 4/12/2022 8:06 AM, Ben wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
As long as the correctly simulated input to H(P,P) cannot possiblyOn 4/11/2022 8:02 PM, Ben wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/11/2022 6:55 PM, Ben wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/10/2022 7:05 PM, Ben wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/10/2022 4:18 PM, Ben wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The truth is not determined by who does or does not agree with
The sequence of configurations specified by P(P) intuitively seemstypo: "so H(P,P) == false is wrong" >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> these facts (since they come from you in the first place). Untilits own final state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Waffle. HP(P) halts so (P,P) == false is wrong. You can retractof posting it once), and the one of H(P,P) return false (you posted thatsomething. But to find the truth of the matter you must first stopproves that the simulated input to H cannot possibly reach its final
talking literal nonsense. The arguments to H (what you call the
"input") are two pointers. What does simulating two pointers mean?
What you mean, I hope, is simulating calling the first pointer with the
second as it's argument. That simulation, according to you, will halt
(or "reach it's final state" in your flamboyant, sciencey, language).
It will halt because the direct call P(P) halts. Everything here halts
(according to you). That's why H is wrong.
You simply are ignoring the actual execution trace that conclusively
own state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The traces that matter are the one of P(P) halting (you made the mistake
as well). You a free to retract any of these at any time, but until you
do, your H is wrong by your own supplied traces.
It is never the case that the simulated input to H(P,P) ever reaches
You can verify a thousand more irrelevant facts. The facts that matterthen, you've told us that your H is wrong.machine address, no waffle there merely an easily verified fact.
It is the case that the simulated input never reaches its [00000970]
are already known: that P(P) halts and that H(P,P) == false. Are you
presenting any verified facts that corrects this mistake? If so, just
say and I'll stop quoting it. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
like it must be identical to the correct simulation of the input to
H(P,P). It turns out that intuition is incorrect.
So which fact are you retracting? That P(P) halts or that H(P,P) ==
false? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
reach the final state of this input then we know that it never halts
even if everyone in the universe disagrees.
So you plan to keep posting the same sentence in an attempt to take
the focus off the fact that H is obviously wrong?
Then you must mean >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You should avoid trying to paraphrase other people. Your replies
suggest you don't often understand the various points being put to you,
so when you try to re-word them the results are usually bogus.
that a correctly simulated input that would never reaches its own
final state is still a computation that halts.
I meant what I said. If you are not sure that I meant, asking
well-chosen questions about it is the way to go.
never reach its own final state is not a halting computation.
Are you saying that the definition of halting is incorrect?
Are you saying that the correctly simulated input to H(P,P) does reach
its own final state? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
it keeps repeating [00000956] to [00000961] until aborted.
_P()
[00000956](01) 55 push ebp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000957](02) 8bec mov ebp,esp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000959](03) 8b4508 mov eax,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000095c](01) 50 push eax // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000095d](03) 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000960](01) 51 push ecx // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000961](05) e8c0feffff call 00000826 // call H(P,P)
The above keeps repeating until aborted >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
[00000966](03) 83c408 add esp,+08 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000969](02) 85c0 test eax,eax >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000096b](02) 7402 jz 0000096f >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000096d](02) ebfe jmp 0000096d >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000096f](01) 5d pop ebp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000970](01) c3 ret // final state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [00000970] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Bill up the street did not rob the liquor store I know this because the
other guy that I know named Bill was watching TV at the time of the
robbery.
So in other words you have no rebuttal because you know that Hb(P,P) == true is correct and proves that H(P,P)==false is incorrect.
proves nothing and is just a disgusting attempt at a head game.
It is not off topic because it directly contradicts your desired result. That you haven't explained why it's wrong is a confirmation of this.
That is why I focus on the X proves Y >>>>>>>>>>>>>>>>>>>>>>>>>>FALSE, because an incorrect simulation is not the same as a turing machine.
(X) We can verify that the simulated input to H(P,P) fails to meet the
Linz definition of
computation that halts … the Turing machine will halt whenever it enters
a final state. (Linz:1990:234) >>>>>>>>>>>>>>>>>>>>>>>>>
(Y) When H(P,P) returns false it is correct. >>>>>>>>>>>>>>>>>>>>>>>>>FALSE, as proved by Hb(P,P) returning true for the same input.
I CAN'T POSSIBLY BE WRONG UNLESS THERE IS AN ESSENTIAL MISTAKE IN X OR Y.
If the simulated input to H(P,P) fails to meet the definition of halting, then Ha3(N,5) also fails to meet that same definition of halting. So that along shows that your criteria is bogus.
I will not tolerate head games. >>>>>>>>>>>>>>>>>>>>>>>
"I will not tolerate arguments that conclusively prove me wrong because I can't bear the though of having wasted the last 17 years".
didn't do it.
Another bad analogy. Further proof that you have no rebuttal.
No, that Hb(P,P)==true is correct by logical necessity. >>>>>>>>>>>>>>>>>> I will dumb it down for you: (Do not not believe in tautologies ?)
Which is isn't as Hb demonstrates
I see you didn't bother to explain why my explanation is wrong. >>>>>>>>>>>>>> If an X <is a> Y and Dennis disagrees then Dennis is a liar. >>>>>>>>>>>>>
denies this therefore Dennis is a liar. Is it fun being a liar? >>>>>>>>>>>
This just shows everyone reading not only that you're wrong, but that you know it.
The simulated input to H(P,P) is non-halting and you know it.
Is it fun being a liar?
You're really struggling with this aren't you?
Unlike everyone else I have a direct measure of your competence, so you >>>>>> can't fool me about what you don't understand.
Then you should have no problem explaining EXACTLY why this is wrong: >>>>>
The simulated input does reach a final state when simulated by Hb.
_P()
[00000956](01) 55 push ebp
[00000957](02) 8bec mov ebp,esp
[00000959](03) 8b4508 mov eax,[ebp+08]
[0000095c](01) 50 push eax // push P
[0000095d](03) 8b4d08 mov ecx,[ebp+08]
[00000960](01) 51 push ecx // push P
[00000961](05) e8c0feffff call 00000826 // call H(P,P)
//The above returns false
[00000966](03) 83c408 add esp,+08
[00000969](02) 85c0 test eax,eax
[0000096b](02) 7402 jz 0000096f
[0000096d](02) ebfe jmp 0000096d
[0000096f](01) 5d pop ebp
[00000970](01) c3 ret // final state.
// Hb reaches the final state of its input
Hb and H are both simulating halt deciders and are given the same input so
both are answering the exact same question but get different results, >>>> As long as the correctly simulated input to H(P,P) would never halt then >>>> we know it is non-halting.
You just keep repeating with no explanation that H(P,P)==false is correct. I explain it detail why it's not.
Hb demonstrates that the correctly simulated input to H(P,P) i.e. (P,P) DOES halt. So find an error:
_P()
[00000956](01) 55 push ebp
[00000957](02) 8bec mov ebp,esp
[00000959](03) 8b4508 mov eax,[ebp+08]
[0000095c](01) 50 push eax // push P
[0000095d](03) 8b4d08 mov ecx,[ebp+08]
[00000960](01) 51 push ecx // push P
[00000961](05) e8c0feffff call 00000826 // call H(P,P)
//The above returns false
[00000966](03) 83c408 add esp,+08
[00000969](02) 85c0 test eax,eax
[0000096b](02) 7402 jz 0000096f
[0000096d](02) ebfe jmp 0000096d
[0000096f](01) 5d pop ebp
[00000970](01) c3 ret // final state.
// Hb reaches the final state of its input
LOGICAL NECESSITY (*It doesn't freaking matter which one).
Hb and H are both simulating halt decidersAs long as the correctly simulated input to H(P,P) would never halt then
and are given the same input so both are
answering the exact same question but get
different results, so one must be wrong. correct.
we know it is non-halting.
Obviously, *if* the correctly simulated input to H(P,P) would never halt then we know it is non-halting. The problem is the correctly simulated input DOES halt.
H makes an abort decision and leaves UTM mode to abort. Hb *never* leaves UTM mode and simulates the input to a final state.
Therefore Hb(P,P)==true is correct, proving that H(P,P)==false is incorrect.
olcott <NoOne@NoWhere.com> writes:
On 4/17/2022 10:20 AM, Ben wrote:
olcott <NoOne@NoWhere.com> writes:
On 4/16/2022 8:08 PM, Ben wrote:If you were right you'd publish the code.
olcott <NoOne@NoWhere.com> writes:
On 4/15/2022 5:03 PM, Ben wrote:
olcott <NoOne@NoWhere.com> writes:
On 4/15/2022 6:48 AM, Ben wrote:
olcott <NoOne@NoWhere.com> writes:
On 4/14/2022 7:12 PM, Ben wrote:
olcott <NoOne@NoWhere.com> writes:
That a non input halts, converts the world to Fascism or opens a very
popular brothel is totally unrelated to the easily confirmed fact that
the input to H(P,P)* does not halt.
The correct value of H(P,P) is determined by the halting status of what
you call a non input:
LIAR LIAR PANTS ON FIRE
No. The correct value of H(P,P) is not for you to choose.
I have proven that the correctly simulated input to H(P,P) never halts >>>>>>>> therefore H would be necessarily correct to report this?
H(M,I) should be false if and only if M(I) does not halt.
The fact that the input H(P,P) is non-halting completely refutes
anything and everyone in the universe that says otherwise.
It's a mantra now.
If I was wrong then the correct simulation of the 27 bytes of machine
code...
This is the only relevant code to the question does the correctly
simulated input to H(P,P) halt?
Clearly not. The code for P is not in doubt.
Sysop: | Keyop |
---|---|
Location: | Huddersfield, West Yorkshire, UK |
Users: | 297 |
Nodes: | 16 (0 / 16) |
Uptime: | 118:17:39 |
Calls: | 6,662 |
Files: | 12,210 |
Messages: | 5,334,298 |