Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES

On 6/15/24 2:55 PM, olcott wrote:

On 6/15/2024 1:08 PM, Richard Damon wrote:

On 6/15/24 1:39 PM, olcott wrote:

On 6/15/2024 12:17 PM, Richard Damon wrote:

On 6/15/24 12:57 PM, olcott wrote:

On 6/13/2024 8:24 PM, Richard Damon wrote:

On 6/13/24 11:32 AM, olcott wrote:

>
It is contingent upon you to show the exact steps of how H computes
the mapping from the x86 machine language finite string input to
H(D,D) using the finite string transformation rules specified by
the semantics of the x86 programming language that reaches the
behavior of the directly executed D(D)
>

>
Why? I don't claim it can.

>
When I ask you to provide the mapping from the input
to H(D,D) to each step of the behavior of D(D) and
and you refuse then within Socratic questioning you
have proved to not be interested in an honest dialog.

>
No, by asking a Red Herring question,

>
*In other words you DO NOT WANT AN HONEST DIALOGUE*

>
No, YOU do not what honest dialogs, as you ask me to try to prove something I don't claim to be do able, and I say why?
>

 In other words you flat out do not understand that H is not
being asked about the behavior of D(D).

Then you don't understand that you just flat out admitted that your H isn't a Halt Decider, and thus you have proven anything about the Halting Problem.

 Through this lack of understanding feel that your assumption
that H is being asked about the behavior of D(D) is justified?

I assume that because you call it a Halt Decider.
I guess you have just been lying about that for all these years.
I guess every time you call something a Halt Decider, I can point out that no it isn't, as you have stated that you machines are not meeting the definition of a Halt Decider.

 

You either fail to understand that your attempt to answer that
question will increase your understanding or you already know
that the answer to that question proves that I am correct.

>
No, I KNOW the question to be a Red Herring, as it actually has NOTHING to do with the problem,

 It has everything to do with a 100% fully specified complete
instance of the problem.

Nope, You just admitted it doesn't.
Halt Deciding, BY DEFINITION, is about the behavior of the program described by the input. By your definiton of D(D), calling H(D,D) is supposed to be asking H to decide on D(D).
If this is not true, you have just admitted that you haven't been working on the halting problem proof for YEARS, and just lying about it.

 

you only think it does, and you want me top prove your false point.
>

>

*YOU* are showing that YOU are not interested in Honest Dialog, because you have been backed in to a corner.

>
You are the one that is backed into a corner here and no amount
of pure bluster will get you out. Failing to provide the requested
steps *is construed as your admission that I am correct*
>

>
What corner am I backed into?
>
The DEFINITION of a Halt Decider is that it answers about the behavior of the directly executed input,

 I prove a counter-example to this that no one ever noticed
before because consistently everyone rejected the notion of
a simulating halt decider out-of-hand without any review
what-so-ever.

NO SUCH THING.
YOU JUST DON'T KNOW THE RULES OF THE GAME
YOU HAVE JUST PROVES THAT YOU ARE A LIAR
Sorry, but that is the truth.

 It IS impossible for the input to H(D,D) to specify
the behavior of D(D) and simply baselessly assuming
otherwise GETS NO WHERE.
 

Nope, you are just showing that you are a total idiot and ignorant of the rules of Compuation Theory.

 not about the partial simulation of it done by the decider.
>

 We can count to 5 and through mathematical induction
we know that we can can beyond 5.

If you can PROVE the induction step, which you haven't done.
I don't think you even know how to do a proper proof by induction.
after all, you don't know how to d a proper proof PERIOD.

 

YOU are the one stuck trying to claim that a wrong answer is right, and have been stuck there for years.
>
No one, but you, cases about what the simulation by H does, as it stops before it gets the answer. We have the correct answer, and it isn't the one H gives.
>

 If it actually stops before it gets an answer then you could
show some finite number of steps of D correctly simulated by
H that reach machine address [00000d1d].

No, D run gets to the correct answer AFTER H stops simulating.

 The ONLY reason that you do not do this is that you know
that I am correct.

Nope, you are STUPID.

 Fascism can only take over the planet while we continue to
have no objective way to divide dangerous lies from truth.
*That kind of thing has been my motivation all along*

YOU ARE JUST SHOWING YOU ARE STUPID.
YOU ARE WORSE THAN THE ELECTION DENIERS.

 _D()
[00000cfc](01) 55          push ebp
[00000cfd](02) 8bec        mov ebp,esp
[00000cff](03) 8b4508      mov eax,[ebp+08]
[00000d02](01) 50          push eax       ; push D
[00000d03](03) 8b4d08      mov ecx,[ebp+08]
[00000d06](01) 51          push ecx       ; push D
[00000d07](05) e800feffff  call 00000b0c  ; call H
[00000d0c](03) 83c408      add esp,+08
[00000d0f](02) 85c0        test eax,eax
[00000d11](02) 7404        jz 00000d17
[00000d13](02) 33c0        xor eax,eax
[00000d15](02) eb05        jmp 00000d1c
[00000d17](05) b801000000  mov eax,00000001
[00000d1c](01) 5d          pop ebp
[00000d1d](01) c3          ret
Size in bytes:(0034) [00000d1d]