No one can possibly provide the exact sequence of D correctly
simulated by H that differs from the one provided below.

*Every rebuttal has always been the pure bluster of dogma*
*with zero supporting exact execution trace*

04 int D(ptr x)
05 {
06 int Halt_Status = H(x, x);
07 if (Halt_Status)
08 HERE: goto HERE;
09 return Halt_Status;
10 }
11
12 void main()
13 {
14 H(D,D);
15 }

*Execution Trace*
Line 14: main() invokes H(D,D);

*keeps repeating* (unless aborted)
Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)

*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 06

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 1/11/24 2:52 PM, olcott wrote:
> No one can possibly provide the exact sequence of D correctly
> simulated by H that differs from the one provided below.
>
> *Every rebuttal has always been the pure bluster of dogma*
> *with zero supporting exact execution trace*
>
> 04 int D(ptr x)
> 05 {
> 06   int Halt_Status = H(x, x);
> 07   if (Halt_Status)
> 08     HERE: goto HERE;
> 09   return Halt_Status;
> 10 }
> 11
> 12 void main()
> 13 {
> 14   H(D,D);
> 15 }
>
> *Execution Trace*
> Line 14: main() invokes H(D,D);
>
> *keeps repeating* (unless aborte
> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>
> *Simulation invariant*
> D correctly simulated by H cannot possibly reach past its own line 06
>

So, you are just showing that you aren't actually interested in Honest
Dialog, because you keep shifting to your Dishonest Strawman.

First, you have ADMITTED that you aren't actually working on the halting
problem, as you have admitted that your input "D" isn't actually a
program but just a program template

Remember, as you quote when you start, the Halting Problem is about
determining if the **PROGRAM** described in the input will halt when
run. This question, ALWAYS has a correct anwer, as any given program,
with its given input, will either Halt or Not, and that specific
combination always does exactly the same thing.

Just like the "Shaving Question", Does George (where George is a
specific person) shave himself, has a definite answer.

The more generic question, Does "The Barber" (without a definitive
context) shave himself doesn't have a definite answer, as some Barbers
shave themselves, and some don't. Just like does D(D), where D is a
program template, not fixed to a single specific program, Halt, doesn't
have a definite answer, as some will halt and some will not, depending
on which specific input you are talking about.

THen we get to the question: "Does the Barber who only shaves those who
don't shave themselves, shave himself?" becomes an incorrect question,
not because of its connection to "Shaving", but because it describes a
person who can't actually exist.

This is just like your "How can a D(D) exist that halts when an H
correctly simulate it and gives the correct answer?"

The problem isn't about the Halting of the input, but of the ability of
an H to exist that both correctly simulates this template, and answers.

Note, you can't assume the existance of such a machine, and because the
actual question is about a SPECIFIC program, you can't use the behavior
of a different actual input based on a different halt decider to justify
your answer for this one.

This is just proving your insanity of thinking that things that are
different are the same.

I will reverse the question, where is the H that actually does a correct
simulation of the input (per the definition of a UTM) that gives an answer?

If you don't have such an actual correct simulation, your "rule" can't
be applied, and you are just shown to be a pathological liar.

You have admitted that your question is a strawman, as you have quoted
that the actual definition of "Halting" is the behavior of the actual
machine reaching a final state.

That is a specific MACHINE (not template)
That is its actual execution (not a simulation)
Sincd the ACTUAL MACHINE doesn't stop until it reaches a final state
(verses a simulation that might be aborted), this shows that the only
way for a simulation to be "correct" is if it isn't aborted. (Thus a
"simulator" that does abort, can't look at its own simulation as
"correct", but must try to predict the behavior of an ACTUAL correct
simulation of the exact same program input (not the same template of the
different simulator).

The fact that this D(D) Halts, when we use the actual H that you claim
to be "correct" to build the D that we give it, shows that H can not be
correct, unless you want to expalin how a wrong answer is correct, but
your logic ignroes the actual facts, and goes by your "reasoning".

By this logic, you agree that Trump is correct that because he claims
there was massive voter fraud, there was in fact massive voter fraud,
and he is actually the current President of the United States.

On 1/11/2024 9:01 PM, Richard Damon wrote:
> On 1/11/24 2:52 PM, olcott wrote:
>> No one can possibly provide the exact sequence of D correctly
>> simulated by H that differs from the one provided below.
>>
>> *Every rebuttal has always been the pure bluster of dogma*
>> *with zero supporting exact execution trace*
>>
>> 04 int D(ptr x)
>> 05 {
>> 06   int Halt_Status = H(x, x);
>> 07   if (Halt_Status)
>> 08     HERE: goto HERE;
>> 09   return Halt_Status;
>> 10 }
>> 11
>> 12 void main()
>> 13 {
>> 14   H(D,D);
>> 15 }
>>
>> *Execution Trace*
>> Line 14: main() invokes H(D,D);
>>
>> *keeps repeating* (unless aborte
>> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>
>> *Simulation invariant*
>> D correctly simulated by H cannot possibly reach past its own line 06
>>
>
> So, you are just showing that you aren't actually interested in Honest
> Dialog, because you keep shifting to your Dishonest Strawman.

No one can possibly provide the exact sequence of D
correctly simulated by H that differs from the above
sequence *thus proving that is it correct*

If I say that 2 + 3 = 27 then you can say that
2 + 3 = 5 and not 27.

If I provide an execution trace that you believe is
incorrect then you can provide the execution trace
of D simulated by H that is correct.

*Failing to do this acknowledges that there is no error*
*Failing to do this acknowledges that there is no error*
*Failing to do this acknowledges that there is no error*
*Failing to do this acknowledges that there is no error*
*Failing to do this acknowledges that there is no error*

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 1/11/2024 1:52 PM, olcott wrote:
> No one can possibly provide the exact sequence of D correctly
> simulated by H that differs from the one provided below.
>
> *Every rebuttal has always been the pure bluster of dogma*
> *with zero supporting exact execution trace*
>
> 04 int D(ptr x) // ptr is a pointer to an int function
> 05 {
> 06   int Halt_Status = H(x, x);
> 07   if (Halt_Status)
> 08     HERE: goto HERE;
> 09   return Halt_Status;
> 10 }
> 11
> 12 void main()
> 13 {
> 14   H(D,D);
> 15 }
>
> *Execution Trace*
> Line 14: main() invokes H(D,D);
>
> *keeps repeating* (unless aborted)
> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>
> *Simulation invariant*
> D correctly simulated by H cannot possibly reach past its own line 06
>

No one can possibly provide the exact sequence of D
correctly simulated by H that differs from the above
sequence *thus proving that is it correct*

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 1/11/24 10:16 PM, olcott wrote:
> On 1/11/2024 9:01 PM, Richard Damon wrote:
>> On 1/11/24 2:52 PM, olcott wrote:
>>> No one can possibly provide the exact sequence of D correctly
>>> simulated by H that differs from the one provided below.
>>>
>>> *Every rebuttal has always been the pure bluster of dogma*
>>> *with zero supporting exact execution trace*
>>>
>>> 04 int D(ptr x)
>>> 05 {
>>> 06   int Halt_Status = H(x, x);
>>> 07   if (Halt_Status)
>>> 08     HERE: goto HERE;
>>> 09   return Halt_Status;
>>> 10 }
>>> 11
>>> 12 void main()
>>> 13 {
>>> 14   H(D,D);
>>> 15 }
>>>
>>> *Execution Trace*
>>> Line 14: main() invokes H(D,D);
>>>
>>> *keeps repeating* (unless aborte
>>> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>
>>> *Simulation invariant*
>>> D correctly simulated by H cannot possibly reach past its own line 06
>>>
>>
>> So, you are just showing that you aren't actually interested in Honest
>> Dialog, because you keep shifting to your Dishonest Strawman.
>
> No one can possibly provide the exact sequence of D
> correctly simulated by H that differs from the above
> sequence *thus proving that is it correct*

What was wrong with my CORRECT SIMULATION of the input?

You haven't refuted the claim that no H does a correct simulation and
returns an value.

>
> If I say that 2 + 3 = 27 then you can say that
> 2 + 3 = 5 and not 27.

DISHONEST STRAWMAN.

>
> If I provide an execution trace that you believe is
> incorrect then you can provide the execution trace
> of D simulated by H that is correct.

You logic L(ES, as you say "unless aborted", but that unless is always
true if H answer, and thus H never meets your claim

>
> *Failing to do this acknowledges that there is no error*
> *Failing to do this acknowledges that there is no error*
> *Failing to do this acknowledges that there is no error*
> *Failing to do this acknowledges that there is no error*
> *Failing to do this acknowledges that there is no error*
>

By that logic, you have admitted that you are a liar, as you haven't
meet MY demand for showing the error in my correct trace (that you
previously provided).

You are just showing that you are clinically insane as you have lost the
ability to distinguish between things that are different.

On 1/11/24 10:21 PM, olcott wrote:
> On 1/11/2024 1:52 PM, olcott wrote:
>> No one can possibly provide the exact sequence of D correctly
>> simulated by H that differs from the one provided below.
>>
>> *Every rebuttal has always been the pure bluster of dogma*
>> *with zero supporting exact execution trace*
>>
>> 04 int D(ptr x)  // ptr is a pointer to an int function
>> 05 {
>> 06   int Halt_Status = H(x, x);
>> 07   if (Halt_Status)
>> 08     HERE: goto HERE;
>> 09   return Halt_Status;
>> 10 }
>> 11
>> 12 void main()
>> 13 {
>> 14   H(D,D);
>> 15 }
>>
>> *Execution Trace*
>> Line 14: main() invokes H(D,D);
>>
>> *keeps repeating* (unless aborted)
>> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>
>> *Simulation invariant*
>> D correctly simulated by H cannot possibly reach past its own line 06
>>
>
> No one can possibly provide the exact sequence of D
> correctly simulated by H that differs from the above
> sequence *thus proving that is it correct*
>
>

But since the trace is self-contadictory, not H actually generates it.

Your trace that proves non-halting needs an H that doesn't abort, but
the H that answers does abort.

Thus, the only "correct" H is the H that both Never Aborts, and does abort.

You are just using flawed logic.

On 1/11/2024 9:34 PM, Richard Damon wrote:
> On 1/11/24 10:16 PM, olcott wrote:
>> On 1/11/2024 9:01 PM, Richard Damon wrote:
>>> On 1/11/24 2:52 PM, olcott wrote:
>>>> No one can possibly provide the exact sequence of D correctly
>>>> simulated by H that differs from the one provided below.
>>>>
>>>> *Every rebuttal has always been the pure bluster of dogma*
>>>> *with zero supporting exact execution trace*
>>>>
>>>> 04 int D(ptr x)
>>>> 05 {
>>>> 06   int Halt_Status = H(x, x);
>>>> 07   if (Halt_Status)
>>>> 08     HERE: goto HERE;
>>>> 09   return Halt_Status;
>>>> 10 }
>>>> 11
>>>> 12 void main()
>>>> 13 {
>>>> 14   H(D,D);
>>>> 15 }
>>>>
>>>> *Execution Trace*
>>>> Line 14: main() invokes H(D,D);
>>>>
>>>> *keeps repeating* (unless aborte
>>>> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>>
>>>> *Simulation invariant*
>>>> D correctly simulated by H cannot possibly reach past its own line 06
>>>>
>>>
>>> So, you are just showing that you aren't actually interested in
>>> Honest Dialog, because you keep shifting to your Dishonest Strawman.
>>
>> No one can possibly provide the exact sequence of D
>> correctly simulated by H that differs from the above
>> sequence *thus proving that is it correct*
>

You didn't provide a line-by-line execution trace of D correctly
simulated by H that provides the exact sequence of the line numbers
of D showing the exact sequence of steps of this simulation.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 1/11/24 10:41 PM, olcott wrote:
> On 1/11/2024 9:34 PM, Richard Damon wrote:
>> On 1/11/24 10:16 PM, olcott wrote:
>>> On 1/11/2024 9:01 PM, Richard Damon wrote:
>>>> On 1/11/24 2:52 PM, olcott wrote:
>>>>> No one can possibly provide the exact sequence of D correctly
>>>>> simulated by H that differs from the one provided below.
>>>>>
>>>>> *Every rebuttal has always been the pure bluster of dogma*
>>>>> *with zero supporting exact execution trace*
>>>>>
>>>>> 04 int D(ptr x)
>>>>> 05 {
>>>>> 06   int Halt_Status = H(x, x);
>>>>> 07   if (Halt_Status)
>>>>> 08     HERE: goto HERE;
>>>>> 09   return Halt_Status;
>>>>> 10 }
>>>>> 11
>>>>> 12 void main()
>>>>> 13 {
>>>>> 14   H(D,D);
>>>>> 15 }
>>>>>
>>>>> *Execution Trace*
>>>>> Line 14: main() invokes H(D,D);
>>>>>
>>>>> *keeps repeating* (unless aborte
>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>>>
>>>>> *Simulation invariant*
>>>>> D correctly simulated by H cannot possibly reach past its own line 06
>>>>>
>>>>
>>>> So, you are just showing that you aren't actually interested in
>>>> Honest Dialog, because you keep shifting to your Dishonest Strawman.
>>>
>>> No one can possibly provide the exact sequence of D
>>> correctly simulated by H that differs from the above
>>> sequence *thus proving that is it correct*
>>
>
> You didn't provide a line-by-line execution trace of D correctly
> simulated by H that provides the exact sequence of the line numbers
> of D showing the exact sequence of steps of this simulation.
>
>

In other words, you aren't actually interested in an answer, just you
making dogmatic assertions. What was the error in the trace I provided
showing the ACTUAL behavior of the machine that you claim to be
answering about, or are you just admitting that you have been lying
about actually working on the halting problem.

Note, as stated, and trimmed, YOUR trace isn't even a correct simulation
by H, as there is no H that does what you say, as your "trace" mixes the
behavior of two different Hs.

So, all you have done is show that no H that meets your requirements
(corectly simulates and answers) exist.

So, until you post an ACTUAL correct trace, showing for a SINGLE
input/decider what happens, that has an ACTUAL "Correct Simulation" (and
thus not aborting as aborting isn't the correct behavior of the program
which doesn't just stop) and an actual answer being given, you are just
proving your deception.

All you have done is proved the theorem you are trying to refute.

On 1/11/2024 10:08 PM, Richard Damon wrote:
> On 1/11/24 10:41 PM, olcott wrote:
>> On 1/11/2024 9:34 PM, Richard Damon wrote:
>>> On 1/11/24 10:16 PM, olcott wrote:
>>>> On 1/11/2024 9:01 PM, Richard Damon wrote:
>>>>> On 1/11/24 2:52 PM, olcott wrote:
>>>>>> No one can possibly provide the exact sequence of D correctly
>>>>>> simulated by H that differs from the one provided below.
>>>>>>
>>>>>> *Every rebuttal has always been the pure bluster of dogma*
>>>>>> *with zero supporting exact execution trace*
>>>>>>
>>>>>> 04 int D(ptr x)
>>>>>> 05 {
>>>>>> 06   int Halt_Status = H(x, x);
>>>>>> 07   if (Halt_Status)
>>>>>> 08     HERE: goto HERE;
>>>>>> 09   return Halt_Status;
>>>>>> 10 }
>>>>>> 11
>>>>>> 12 void main()
>>>>>> 13 {
>>>>>> 14   H(D,D);
>>>>>> 15 }
>>>>>>
>>>>>> *Execution Trace*
>>>>>> Line 14: main() invokes H(D,D);
>>>>>>
>>>>>> *keeps repeating* (unless aborte
>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>>>>
>>>>>> *Simulation invariant*
>>>>>> D correctly simulated by H cannot possibly reach past its own line 06
>>>>>>
>>>>>
>>>>> So, you are just showing that you aren't actually interested in
>>>>> Honest Dialog, because you keep shifting to your Dishonest Strawman.
>>>>
>>>> No one can possibly provide the exact sequence of D
>>>> correctly simulated by H that differs from the above
>>>> sequence *thus proving that is it correct*
>>>
>>
>> You didn't provide a line-by-line execution trace of D correctly
>> simulated by H that provides the exact sequence of the line numbers
>> of D showing the exact sequence of steps of this simulation.
>>
>>
>
> In other words, you aren't actually interested in an answer,

A correct rebuttal of the above has a single form everything
else is merely double-talk.

*If you say that my trace is wrong then you can either provide*
*the correct trace or utterly fail to provide any rebuttal*

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 1/12/24 04:36, Richard Damon wrote:
> On 1/11/24 10:21 PM, olcott wrote:
>> On 1/11/2024 1:52 PM, olcott wrote:
>>> No one can possibly provide the exact sequence of D correctly
>>> simulated by H that differs from the one provided below.
>>>
>>> *Every rebuttal has always been the pure bluster of dogma*
>>> *with zero supporting exact execution trace*
>>>
>>> 04 int D(ptr x)  // ptr is a pointer to an int function
>>> 05 {
>>> 06   int Halt_Status = H(x, x);
>>> 07   if (Halt_Status)
>>> 08     HERE: goto HERE;
>>> 09   return Halt_Status;
>>> 10 }
>>> 11
>>> 12 void main()
>>> 13 {
>>> 14   H(D,D);
>>> 15 }
>>>
>>> *Execution Trace*
>>> Line 14: main() invokes H(D,D);
>>>
>>> *keeps repeating* (unless aborted)
>>> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>
>>> *Simulation invariant*
>>> D correctly simulated by H cannot possibly reach past its own line 06
>>>
>>
>> No one can possibly provide the exact sequence of D
>> correctly simulated by H that differs from the above
>> sequence *thus proving that is it correct*
>>
>>
>
> But since the trace is self-contadictory, not H actually generates it.
>
> Your trace that proves non-halting needs an H that doesn't abort, but
> the H that answers does abort.
>
> Thus, the only "correct" H is the H that both Never Aborts, and does abort.
>
> You are just using flawed logic.

Olcott seems to have decided he isn't solving the halting problem, but a
different problem. "Correct" apparently means the trace actually
generated when H "simulates" H, not the one you get by actually running
H. We know that the trace of actually running H is completely different
from the trace of H simulating H, so

A lot of people told Olcott things like "the execution correct trace of
the simulation halts if the program halts" but when they said "correct"
they meant "correct" and not "what Olcott gets when he runs his program"
but Olcott interpreted it as "what Olcott gets when he runs his program"

On 1/12/24 04:41, olcott wrote:
> On 1/11/2024 9:34 PM, Richard Damon wrote:
>> On 1/11/24 10:16 PM, olcott wrote:
>>> On 1/11/2024 9:01 PM, Richard Damon wrote:
>>>> On 1/11/24 2:52 PM, olcott wrote:
>>>>> No one can possibly provide the exact sequence of D correctly
>>>>> simulated by H that differs from the one provided below.
>>>>>
>>>>> *Every rebuttal has always been the pure bluster of dogma*
>>>>> *with zero supporting exact execution trace*
>>>>>
>>>>> 04 int D(ptr x)
>>>>> 05 {
>>>>> 06   int Halt_Status = H(x, x);
>>>>> 07   if (Halt_Status)
>>>>> 08     HERE: goto HERE;
>>>>> 09   return Halt_Status;
>>>>> 10 }
>>>>> 11
>>>>> 12 void main()
>>>>> 13 {
>>>>> 14   H(D,D);
>>>>> 15 }
>>>>>
>>>>> *Execution Trace*
>>>>> Line 14: main() invokes H(D,D);
>>>>>
>>>>> *keeps repeating* (unless aborte
>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>>>
>>>>> *Simulation invariant*
>>>>> D correctly simulated by H cannot possibly reach past its own line 06
>>>>>
>>>>
>>>> So, you are just showing that you aren't actually interested in
>>>> Honest Dialog, because you keep shifting to your Dishonest Strawman.
>>>
>>> No one can possibly provide the exact sequence of D
>>> correctly simulated by H that differs from the above
>>> sequence *thus proving that is it correct*
>>
>
> You didn't provide a line-by-line execution trace of D correctly
> simulated by H that provides the exact sequence of the line numbers
> of D showing the exact sequence of steps of this simulation.
>
>
You can generate it yourself. Simply run H1 on D.

On 1/11/24 11:31 PM, olcott wrote:
> On 1/11/2024 10:08 PM, Richard Damon wrote:
>> On 1/11/24 10:41 PM, olcott wrote:
>>> On 1/11/2024 9:34 PM, Richard Damon wrote:
>>>> On 1/11/24 10:16 PM, olcott wrote:
>>>>> On 1/11/2024 9:01 PM, Richard Damon wrote:
>>>>>> On 1/11/24 2:52 PM, olcott wrote:
>>>>>>> No one can possibly provide the exact sequence of D correctly
>>>>>>> simulated by H that differs from the one provided below.
>>>>>>>
>>>>>>> *Every rebuttal has always been the pure bluster of dogma*
>>>>>>> *with zero supporting exact execution trace*
>>>>>>>
>>>>>>> 04 int D(ptr x)
>>>>>>> 05 {
>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>> 07   if (Halt_Status)
>>>>>>> 08     HERE: goto HERE;
>>>>>>> 09   return Halt_Status;
>>>>>>> 10 }
>>>>>>> 11
>>>>>>> 12 void main()
>>>>>>> 13 {
>>>>>>> 14   H(D,D);
>>>>>>> 15 }
>>>>>>>
>>>>>>> *Execution Trace*
>>>>>>> Line 14: main() invokes H(D,D);
>>>>>>>
>>>>>>> *keeps repeating* (unless aborte
>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>>>>>
>>>>>>> *Simulation invariant*
>>>>>>> D correctly simulated by H cannot possibly reach past its own
>>>>>>> line 06
>>>>>>>
>>>>>>
>>>>>> So, you are just showing that you aren't actually interested in
>>>>>> Honest Dialog, because you keep shifting to your Dishonest Strawman.
>>>>>
>>>>> No one can possibly provide the exact sequence of D
>>>>> correctly simulated by H that differs from the above
>>>>> sequence *thus proving that is it correct*
>>>>
>>>
>>> You didn't provide a line-by-line execution trace of D correctly
>>> simulated by H that provides the exact sequence of the line numbers
>>> of D showing the exact sequence of steps of this simulation.
>>>
>>>
>>
>> In other words, you aren't actually interested in an answer,
>
> A correct rebuttal of the above has a single form everything
> else is merely double-talk.
>
> *If you say that my trace is wrong then you can either provide*
> *the correct trace or utterly fail to provide any rebuttal*
>
>

In other words you are just admitting to your use of a dishonest dodge
and invalid argument.

The only "correct" trace, for this question is H running forever in the
simulation loop, as it isn't alllowed to abort and be a correct simulation.

Your term "unless aborted" could be translated as, unless I lie.

No H exists that actually does a correct simulation and gives an answer
to this template.

Any H that doesn't do a correct simulation, because it aborts, shows
that its conclusion is false, because the actual correct simulation
(Which this H can't do, so the criteria claiming it does is invalid)
shows the input Halts.

You are just proving you just don't understand about things like Truth,
Correct, Logic.

On 1/12/2024 1:26 AM, immibis wrote:
> On 1/12/24 04:41, olcott wrote:
>> On 1/11/2024 9:34 PM, Richard Damon wrote:
>>> On 1/11/24 10:16 PM, olcott wrote:
>>>> On 1/11/2024 9:01 PM, Richard Damon wrote:
>>>>> On 1/11/24 2:52 PM, olcott wrote:
>>>>>> No one can possibly provide the exact sequence of D correctly
>>>>>> simulated by H that differs from the one provided below.
>>>>>>
>>>>>> *Every rebuttal has always been the pure bluster of dogma*
>>>>>> *with zero supporting exact execution trace*
>>>>>>
>>>>>> 04 int D(ptr x)
>>>>>> 05 {
>>>>>> 06   int Halt_Status = H(x, x);
>>>>>> 07   if (Halt_Status)
>>>>>> 08     HERE: goto HERE;
>>>>>> 09   return Halt_Status;
>>>>>> 10 }
>>>>>> 11
>>>>>> 12 void main()
>>>>>> 13 {
>>>>>> 14   H(D,D);
>>>>>> 15 }
>>>>>>
>>>>>> *Execution Trace*
>>>>>> Line 14: main() invokes H(D,D);
>>>>>>
>>>>>> *keeps repeating* (unless aborte
>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>>>>
>>>>>> *Simulation invariant*
>>>>>> D correctly simulated by H cannot possibly reach past its own line 06
>>>>>>
>>>>>
>>>>> So, you are just showing that you aren't actually interested in
>>>>> Honest Dialog, because you keep shifting to your Dishonest Strawman.
>>>>
>>>> No one can possibly provide the exact sequence of D
>>>> correctly simulated by H that differs from the above
>>>> sequence *thus proving that is it correct*
>>>
>>
>> You didn't provide a line-by-line execution trace of D correctly
>> simulated by H that provides the exact sequence of the line numbers
>> of D showing the exact sequence of steps of this simulation.
>>
>>
> You can generate it yourself. Simply run H1 on D.

In other words when someone sees Bill rob the liquor store then
this proves that Jim and not Bill robbed the liquor store?

The correct simulation of D by H cannot be shown by the correct
simulation of D by H1. Why do you think that you can get away
with this? When I ask for the sum of 2 + 3 you cannot change this
to the sum of 5 + 7.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 1/12/2024 6:30 AM, Richard Damon wrote:
> On 1/11/24 11:31 PM, olcott wrote:
>> On 1/11/2024 10:08 PM, Richard Damon wrote:
>>> On 1/11/24 10:41 PM, olcott wrote:
>>>> On 1/11/2024 9:34 PM, Richard Damon wrote:
>>>>> On 1/11/24 10:16 PM, olcott wrote:
>>>>>> On 1/11/2024 9:01 PM, Richard Damon wrote:
>>>>>>> On 1/11/24 2:52 PM, olcott wrote:
>>>>>>>> No one can possibly provide the exact sequence of D correctly
>>>>>>>> simulated by H that differs from the one provided below.
>>>>>>>>
>>>>>>>> *Every rebuttal has always been the pure bluster of dogma*
>>>>>>>> *with zero supporting exact execution trace*
>>>>>>>>
>>>>>>>> 04 int D(ptr x)
>>>>>>>> 05 {
>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>> 07   if (Halt_Status)
>>>>>>>> 08     HERE: goto HERE;
>>>>>>>> 09   return Halt_Status;
>>>>>>>> 10 }
>>>>>>>> 11
>>>>>>>> 12 void main()
>>>>>>>> 13 {
>>>>>>>> 14   H(D,D);
>>>>>>>> 15 }
>>>>>>>>
>>>>>>>> *Execution Trace*
>>>>>>>> Line 14: main() invokes H(D,D);
>>>>>>>>
>>>>>>>> *keeps repeating* (unless aborte
>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that simulates
>>>>>>>> D(D)
>>>>>>>>
>>>>>>>> *Simulation invariant*
>>>>>>>> D correctly simulated by H cannot possibly reach past its own
>>>>>>>> line 06
>>>>>>>>
>>>>>>>
>>>>>>> So, you are just showing that you aren't actually interested in
>>>>>>> Honest Dialog, because you keep shifting to your Dishonest Strawman.
>>>>>>
>>>>>> No one can possibly provide the exact sequence of D
>>>>>> correctly simulated by H that differs from the above
>>>>>> sequence *thus proving that is it correct*
>>>>>
>>>>
>>>> You didn't provide a line-by-line execution trace of D correctly
>>>> simulated by H that provides the exact sequence of the line numbers
>>>> of D showing the exact sequence of steps of this simulation.
>>>>
>>>>
>>>
>>> In other words, you aren't actually interested in an answer,
>>
>> A correct rebuttal of the above has a single form everything
>> else is merely double-talk.
>>
>> *If you say that my trace is wrong then you can either provide*
>> *the correct trace or utterly fail to provide any rebuttal*
>>
>>
>
> In other words you are just admitting

That you refuse to provide a proper rebuttal because you
already know that I am correct and there is no proper rebuttal.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 1/12/24 16:01, olcott wrote:
> On 1/12/2024 1:26 AM, immibis wrote:
>> On 1/12/24 04:41, olcott wrote:
>>> On 1/11/2024 9:34 PM, Richard Damon wrote:
>>>> On 1/11/24 10:16 PM, olcott wrote:
>>>>> On 1/11/2024 9:01 PM, Richard Damon wrote:
>>>>>> On 1/11/24 2:52 PM, olcott wrote:
>>>>>>> No one can possibly provide the exact sequence of D correctly
>>>>>>> simulated by H that differs from the one provided below.
>>>>>>>
>>>>>>> *Every rebuttal has always been the pure bluster of dogma*
>>>>>>> *with zero supporting exact execution trace*
>>>>>>>
>>>>>>> 04 int D(ptr x)
>>>>>>> 05 {
>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>> 07   if (Halt_Status)
>>>>>>> 08     HERE: goto HERE;
>>>>>>> 09   return Halt_Status;
>>>>>>> 10 }
>>>>>>> 11
>>>>>>> 12 void main()
>>>>>>> 13 {
>>>>>>> 14   H(D,D);
>>>>>>> 15 }
>>>>>>>
>>>>>>> *Execution Trace*
>>>>>>> Line 14: main() invokes H(D,D);
>>>>>>>
>>>>>>> *keeps repeating* (unless aborte
>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>>>>>
>>>>>>> *Simulation invariant*
>>>>>>> D correctly simulated by H cannot possibly reach past its own
>>>>>>> line 06
>>>>>>>
>>>>>>
>>>>>> So, you are just showing that you aren't actually interested in
>>>>>> Honest Dialog, because you keep shifting to your Dishonest Strawman.
>>>>>
>>>>> No one can possibly provide the exact sequence of D
>>>>> correctly simulated by H that differs from the above
>>>>> sequence *thus proving that is it correct*
>>>>
>>>
>>> You didn't provide a line-by-line execution trace of D correctly
>>> simulated by H that provides the exact sequence of the line numbers
>>> of D showing the exact sequence of steps of this simulation.
>>>
>>>
>> You can generate it yourself. Simply run H1 on D.
>
> In other words when someone sees Bill rob the liquor store then
> this proves that Jim and not Bill robbed the liquor store?

The correct simulation trace is the one which H1 generates.

On 1/12/24 17:17, olcott wrote:
> On 1/12/2024 6:30 AM, Richard Damon wrote:
>> On 1/11/24 11:31 PM, olcott wrote:
>>> On 1/11/2024 10:08 PM, Richard Damon wrote:
>>>> On 1/11/24 10:41 PM, olcott wrote:
>>>>> On 1/11/2024 9:34 PM, Richard Damon wrote:
>>>>>> On 1/11/24 10:16 PM, olcott wrote:
>>>>>>> On 1/11/2024 9:01 PM, Richard Damon wrote:
>>>>>>>> On 1/11/24 2:52 PM, olcott wrote:
>>>>>>>>> No one can possibly provide the exact sequence of D correctly
>>>>>>>>> simulated by H that differs from the one provided below.
>>>>>>>>>
>>>>>>>>> *Every rebuttal has always been the pure bluster of dogma*
>>>>>>>>> *with zero supporting exact execution trace*
>>>>>>>>>
>>>>>>>>> 04 int D(ptr x)
>>>>>>>>> 05 {
>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>> 09   return Halt_Status;
>>>>>>>>> 10 }
>>>>>>>>> 11
>>>>>>>>> 12 void main()
>>>>>>>>> 13 {
>>>>>>>>> 14   H(D,D);
>>>>>>>>> 15 }
>>>>>>>>>
>>>>>>>>> *Execution Trace*
>>>>>>>>> Line 14: main() invokes H(D,D);
>>>>>>>>>
>>>>>>>>> *keeps repeating* (unless aborte
>>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that simulates
>>>>>>>>> D(D)
>>>>>>>>>
>>>>>>>>> *Simulation invariant*
>>>>>>>>> D correctly simulated by H cannot possibly reach past its own
>>>>>>>>> line 06
>>>>>>>>>
>>>>>>>>
>>>>>>>> So, you are just showing that you aren't actually interested in
>>>>>>>> Honest Dialog, because you keep shifting to your Dishonest
>>>>>>>> Strawman.
>>>>>>>
>>>>>>> No one can possibly provide the exact sequence of D
>>>>>>> correctly simulated by H that differs from the above
>>>>>>> sequence *thus proving that is it correct*
>>>>>>
>>>>>
>>>>> You didn't provide a line-by-line execution trace of D correctly
>>>>> simulated by H that provides the exact sequence of the line numbers
>>>>> of D showing the exact sequence of steps of this simulation.
>>>>>
>>>>>
>>>>
>>>> In other words, you aren't actually interested in an answer,
>>>
>>> A correct rebuttal of the above has a single form everything
>>> else is merely double-talk.
>>>
>>> *If you say that my trace is wrong then you can either provide*
>>> *the correct trace or utterly fail to provide any rebuttal*
>>>
>>>
>>
>> In other words you are just admitting
>
> That you refuse to provide a proper rebuttal because you
> already know that I am correct and there is no proper rebuttal.
>
You failed to provide a proper rebuttal to Linz because you already know
he is correct and there is no propre rebuttal.

On 1/12/24 04:16, olcott wrote:
> On 1/11/2024 9:01 PM, Richard Damon wrote:
>> On 1/11/24 2:52 PM, olcott wrote:
>>> No one can possibly provide the exact sequence of D correctly
>>> simulated by H that differs from the one provided below.
>>>
>>> *Every rebuttal has always been the pure bluster of dogma*
>>> *with zero supporting exact execution trace*
>>>
>>> 04 int D(ptr x)
>>> 05 {
>>> 06   int Halt_Status = H(x, x);
>>> 07   if (Halt_Status)
>>> 08     HERE: goto HERE;
>>> 09   return Halt_Status;
>>> 10 }
>>> 11
>>> 12 void main()
>>> 13 {
>>> 14   H(D,D);
>>> 15 }
>>>
>>> *Execution Trace*
>>> Line 14: main() invokes H(D,D);
>>>
>>> *keeps repeating* (unless aborte
>>> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>
>>> *Simulation invariant*
>>> D correctly simulated by H cannot possibly reach past its own line 06
>>>
>>
>> So, you are just showing that you aren't actually interested in Honest
>> Dialog, because you keep shifting to your Dishonest Strawman.
>
> No one can possibly provide the exact sequence of D
> correctly simulated by H that differs from the above
> sequence *thus proving that is it correct*
>
> If I say that 2 + 3 = 27 then you can say that
> 2 + 3 = 5 and not 27.

If I say that the time is yes, do you have to tell me what the tim eis?

>
> If I provide an execution trace that you believe is
> incorrect then you can provide the execution trace
> of D simulated by H that is correct.
>
> *Failing to do this acknowledges that there is no error*
> *Failing to do this acknowledges that there is no error*
> *Failing to do this acknowledges that there is no error*
> *Failing to do this acknowledges that there is no error*
> *Failing to do this acknowledges that there is no error*
>
>

On 1/12/2024 10:31 AM, immibis wrote:
> On 1/12/24 16:01, olcott wrote:
>> On 1/12/2024 1:26 AM, immibis wrote:
>>> On 1/12/24 04:41, olcott wrote:
>>>> On 1/11/2024 9:34 PM, Richard Damon wrote:
>>>>> On 1/11/24 10:16 PM, olcott wrote:
>>>>>> On 1/11/2024 9:01 PM, Richard Damon wrote:
>>>>>>> On 1/11/24 2:52 PM, olcott wrote:
>>>>>>>> No one can possibly provide the exact sequence of D correctly
>>>>>>>> simulated by H that differs from the one provided below.
>>>>>>>>
>>>>>>>> *Every rebuttal has always been the pure bluster of dogma*
>>>>>>>> *with zero supporting exact execution trace*
>>>>>>>>
>>>>>>>> 04 int D(ptr x)
>>>>>>>> 05 {
>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>> 07   if (Halt_Status)
>>>>>>>> 08     HERE: goto HERE;
>>>>>>>> 09   return Halt_Status;
>>>>>>>> 10 }
>>>>>>>> 11
>>>>>>>> 12 void main()
>>>>>>>> 13 {
>>>>>>>> 14   H(D,D);
>>>>>>>> 15 }
>>>>>>>>
>>>>>>>> *Execution Trace*
>>>>>>>> Line 14: main() invokes H(D,D);
>>>>>>>>
>>>>>>>> *keeps repeating* (unless aborte
>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that simulates
>>>>>>>> D(D)
>>>>>>>>
>>>>>>>> *Simulation invariant*
>>>>>>>> D correctly simulated by H cannot possibly reach past its own
>>>>>>>> line 06
>>>>>>>>
>>>>>>>
>>>>>>> So, you are just showing that you aren't actually interested in
>>>>>>> Honest Dialog, because you keep shifting to your Dishonest Strawman.
>>>>>>
>>>>>> No one can possibly provide the exact sequence of D
>>>>>> correctly simulated by H that differs from the above
>>>>>> sequence *thus proving that is it correct*
>>>>>
>>>>
>>>> You didn't provide a line-by-line execution trace of D correctly
>>>> simulated by H that provides the exact sequence of the line numbers
>>>> of D showing the exact sequence of steps of this simulation.
>>>>
>>>>
>>> You can generate it yourself. Simply run H1 on D.
>>
>> In other words when someone sees Bill rob the liquor store then
>> this proves that Jim and not Bill robbed the liquor store?
>
> The correct simulation trace is the one which H1 generates.

So then the eye witness that confirms that Bill and not Jim
robbed the liquor store proves that Jim robbed the liquor store.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 1/12/2024 10:37 AM, immibis wrote:
> On 1/12/24 17:17, olcott wrote:
>> On 1/12/2024 6:30 AM, Richard Damon wrote:
>>> On 1/11/24 11:31 PM, olcott wrote:
>>>> On 1/11/2024 10:08 PM, Richard Damon wrote:
>>>>> On 1/11/24 10:41 PM, olcott wrote:
>>>>>> On 1/11/2024 9:34 PM, Richard Damon wrote:
>>>>>>> On 1/11/24 10:16 PM, olcott wrote:
>>>>>>>> On 1/11/2024 9:01 PM, Richard Damon wrote:
>>>>>>>>> On 1/11/24 2:52 PM, olcott wrote:
>>>>>>>>>> No one can possibly provide the exact sequence of D correctly
>>>>>>>>>> simulated by H that differs from the one provided below.
>>>>>>>>>>
>>>>>>>>>> *Every rebuttal has always been the pure bluster of dogma*
>>>>>>>>>> *with zero supporting exact execution trace*
>>>>>>>>>>
>>>>>>>>>> 04 int D(ptr x)
>>>>>>>>>> 05 {
>>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>>> 09   return Halt_Status;
>>>>>>>>>> 10 }
>>>>>>>>>> 11
>>>>>>>>>> 12 void main()
>>>>>>>>>> 13 {
>>>>>>>>>> 14   H(D,D);
>>>>>>>>>> 15 }
>>>>>>>>>>
>>>>>>>>>> *Execution Trace*
>>>>>>>>>> Line 14: main() invokes H(D,D);
>>>>>>>>>>
>>>>>>>>>> *keeps repeating* (unless aborte
>>>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that
>>>>>>>>>> simulates D(D)
>>>>>>>>>>
>>>>>>>>>> *Simulation invariant*
>>>>>>>>>> D correctly simulated by H cannot possibly reach past its own
>>>>>>>>>> line 06
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> So, you are just showing that you aren't actually interested in
>>>>>>>>> Honest Dialog, because you keep shifting to your Dishonest
>>>>>>>>> Strawman.
>>>>>>>>
>>>>>>>> No one can possibly provide the exact sequence of D
>>>>>>>> correctly simulated by H that differs from the above
>>>>>>>> sequence *thus proving that is it correct*
>>>>>>>
>>>>>>
>>>>>> You didn't provide a line-by-line execution trace of D correctly
>>>>>> simulated by H that provides the exact sequence of the line numbers
>>>>>> of D showing the exact sequence of steps of this simulation.
>>>>>>
>>>>>>
>>>>>
>>>>> In other words, you aren't actually interested in an answer,
>>>>
>>>> A correct rebuttal of the above has a single form everything
>>>> else is merely double-talk.
>>>>
>>>> *If you say that my trace is wrong then you can either provide*
>>>> *the correct trace or utterly fail to provide any rebuttal*
>>>>
>>>>
>>>
>>> In other words you are just admitting
>>
>> That you refuse to provide a proper rebuttal because you
>> already know that I am correct and there is no proper rebuttal.
>>
> You failed to provide a proper rebuttal to Linz because you already know
> he is correct and there is no propre rebuttal.

Changing the subject instead of providing the exactly correct sequence
of line numbers of D correctly simulated by H is simply a dishonest
dodge.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 1/12/24 11:40 AM, olcott wrote:
> On 1/12/2024 10:31 AM, immibis wrote:
>> On 1/12/24 16:01, olcott wrote:
>>> On 1/12/2024 1:26 AM, immibis wrote:
>>>> On 1/12/24 04:41, olcott wrote:
>>>>> On 1/11/2024 9:34 PM, Richard Damon wrote:
>>>>>> On 1/11/24 10:16 PM, olcott wrote:
>>>>>>> On 1/11/2024 9:01 PM, Richard Damon wrote:
>>>>>>>> On 1/11/24 2:52 PM, olcott wrote:
>>>>>>>>> No one can possibly provide the exact sequence of D correctly
>>>>>>>>> simulated by H that differs from the one provided below.
>>>>>>>>>
>>>>>>>>> *Every rebuttal has always been the pure bluster of dogma*
>>>>>>>>> *with zero supporting exact execution trace*
>>>>>>>>>
>>>>>>>>> 04 int D(ptr x)
>>>>>>>>> 05 {
>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>> 09   return Halt_Status;
>>>>>>>>> 10 }
>>>>>>>>> 11
>>>>>>>>> 12 void main()
>>>>>>>>> 13 {
>>>>>>>>> 14   H(D,D);
>>>>>>>>> 15 }
>>>>>>>>>
>>>>>>>>> *Execution Trace*
>>>>>>>>> Line 14: main() invokes H(D,D);
>>>>>>>>>
>>>>>>>>> *keeps repeating* (unless aborte
>>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that simulates
>>>>>>>>> D(D)
>>>>>>>>>
>>>>>>>>> *Simulation invariant*
>>>>>>>>> D correctly simulated by H cannot possibly reach past its own
>>>>>>>>> line 06
>>>>>>>>>
>>>>>>>>
>>>>>>>> So, you are just showing that you aren't actually interested in
>>>>>>>> Honest Dialog, because you keep shifting to your Dishonest
>>>>>>>> Strawman.
>>>>>>>
>>>>>>> No one can possibly provide the exact sequence of D
>>>>>>> correctly simulated by H that differs from the above
>>>>>>> sequence *thus proving that is it correct*
>>>>>>
>>>>>
>>>>> You didn't provide a line-by-line execution trace of D correctly
>>>>> simulated by H that provides the exact sequence of the line numbers
>>>>> of D showing the exact sequence of steps of this simulation.
>>>>>
>>>>>
>>>> You can generate it yourself. Simply run H1 on D.
>>>
>>> In other words when someone sees Bill rob the liquor store then
>>> this proves that Jim and not Bill robbed the liquor store?
>>
>> The correct simulation trace is the one which H1 generates.
>
> So then the eye witness that confirms that Bill and not Jim
> robbed the liquor store proves that Jim robbed the liquor store.
>

WHere do you get that from?

H1 has the eye-witness that a properly simulated D(D) reaches a final
state and halts.

That PROVES that H did an INCORRECT simulation, incorrect in that it
stopped before getting the actual right answer.

Where did H1 claim something wrong?

Remeber, the DEFINITION of Halting is that it is the property of the
MACHINE reaching it final state, and machies don't stop until they get
there (or run forever, and thus be non-halting). H stopping and claiming
it has the answer is the one bearing false witness.

On 1/12/24 1:50 PM, olcott wrote:
>
> Changing the subject instead of providing the exactly correct sequence
> of line numbers of D correctly simulated by H is simply a dishonest
> dodge.
>

Except that your question was just such a dishonest dodge where you are
trying to avoid answering all the prior errors pointed out in your logic.

You have FAILED, and I think you "know" it, but can not accept it.

On 1/12/24 11:17 AM, olcott wrote:
> On 1/12/2024 6:30 AM, Richard Damon wrote:
>> On 1/11/24 11:31 PM, olcott wrote:
>>> On 1/11/2024 10:08 PM, Richard Damon wrote:
>>>> On 1/11/24 10:41 PM, olcott wrote:
>>>>> On 1/11/2024 9:34 PM, Richard Damon wrote:
>>>>>> On 1/11/24 10:16 PM, olcott wrote:
>>>>>>> On 1/11/2024 9:01 PM, Richard Damon wrote:
>>>>>>>> On 1/11/24 2:52 PM, olcott wrote:
>>>>>>>>> No one can possibly provide the exact sequence of D correctly
>>>>>>>>> simulated by H that differs from the one provided below.
>>>>>>>>>
>>>>>>>>> *Every rebuttal has always been the pure bluster of dogma*
>>>>>>>>> *with zero supporting exact execution trace*
>>>>>>>>>
>>>>>>>>> 04 int D(ptr x)
>>>>>>>>> 05 {
>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>> 09   return Halt_Status;
>>>>>>>>> 10 }
>>>>>>>>> 11
>>>>>>>>> 12 void main()
>>>>>>>>> 13 {
>>>>>>>>> 14   H(D,D);
>>>>>>>>> 15 }
>>>>>>>>>
>>>>>>>>> *Execution Trace*
>>>>>>>>> Line 14: main() invokes H(D,D);
>>>>>>>>>
>>>>>>>>> *keeps repeating* (unless aborte
>>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that simulates
>>>>>>>>> D(D)
>>>>>>>>>
>>>>>>>>> *Simulation invariant*
>>>>>>>>> D correctly simulated by H cannot possibly reach past its own
>>>>>>>>> line 06
>>>>>>>>>
>>>>>>>>
>>>>>>>> So, you are just showing that you aren't actually interested in
>>>>>>>> Honest Dialog, because you keep shifting to your Dishonest
>>>>>>>> Strawman.
>>>>>>>
>>>>>>> No one can possibly provide the exact sequence of D
>>>>>>> correctly simulated by H that differs from the above
>>>>>>> sequence *thus proving that is it correct*
>>>>>>
>>>>>
>>>>> You didn't provide a line-by-line execution trace of D correctly
>>>>> simulated by H that provides the exact sequence of the line numbers
>>>>> of D showing the exact sequence of steps of this simulation.
>>>>>
>>>>>
>>>>
>>>> In other words, you aren't actually interested in an answer,
>>>
>>> A correct rebuttal of the above has a single form everything
>>> else is merely double-talk.
>>>
>>> *If you say that my trace is wrong then you can either provide*
>>> *the correct trace or utterly fail to provide any rebuttal*
>>>
>>>
>>
>> In other words you are just admitting
>
> That you refuse to provide a proper rebuttal because you
> already know that I am correct and there is no proper rebuttal.
>

Trimmed quote:

In other words you are just admitting to your use of a dishonest dodge
and invalid argument.

The only "correct" trace, for this question is H running forever in the
simulation loop, as it isn't alllowed to abort and be a correct simulation.

Your term "unless aborted" could be translated as, unless I lie.

No H exists that actually does a correct simulation and gives an answer
to this template.

Any H that doesn't do a correct simulation, because it aborts, shows
that its conclusion is false, because the actual correct simulation
(Which this H can't do, so the criteria claiming it does is invalid)
shows the input Halts.

You are just proving you just don't understand about things like Truth,
Correct, Logic.

Which just shows that YOU are the one to refuse to provide a proper rebuttal

One thought I had is that you don't seem to understand the difference
between volitional being sthat have free-will and deterministic programs
that do not, and wondered if you sold your soul to the Devil (and thus
gave up your own free-will) in excange for something, and you are now
stuck in your buggy program that has hit an infinite loop.

Maybe that is why you are so anxious about developing Artificial
Intelligence, since you lost your own intelegence.

On 1/12/24 19:50, olcott wrote:
> On 1/12/2024 10:37 AM, immibis wrote:
>> On 1/12/24 17:17, olcott wrote:
>>> On 1/12/2024 6:30 AM, Richard Damon wrote:
>>>> On 1/11/24 11:31 PM, olcott wrote:
>>>>> On 1/11/2024 10:08 PM, Richard Damon wrote:
>>>>>> On 1/11/24 10:41 PM, olcott wrote:
>>>>>>> On 1/11/2024 9:34 PM, Richard Damon wrote:
>>>>>>>> On 1/11/24 10:16 PM, olcott wrote:
>>>>>>>>> On 1/11/2024 9:01 PM, Richard Damon wrote:
>>>>>>>>>> On 1/11/24 2:52 PM, olcott wrote:
>>>>>>>>>>> No one can possibly provide the exact sequence of D correctly
>>>>>>>>>>> simulated by H that differs from the one provided below.
>>>>>>>>>>>
>>>>>>>>>>> *Every rebuttal has always been the pure bluster of dogma*
>>>>>>>>>>> *with zero supporting exact execution trace*
>>>>>>>>>>>
>>>>>>>>>>> 04 int D(ptr x)
>>>>>>>>>>> 05 {
>>>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>>>> 09   return Halt_Status;
>>>>>>>>>>> 10 }
>>>>>>>>>>> 11
>>>>>>>>>>> 12 void main()
>>>>>>>>>>> 13 {
>>>>>>>>>>> 14   H(D,D);
>>>>>>>>>>> 15 }
>>>>>>>>>>>
>>>>>>>>>>> *Execution Trace*
>>>>>>>>>>> Line 14: main() invokes H(D,D);
>>>>>>>>>>>
>>>>>>>>>>> *keeps repeating* (unless aborte
>>>>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that
>>>>>>>>>>> simulates D(D)
>>>>>>>>>>>
>>>>>>>>>>> *Simulation invariant*
>>>>>>>>>>> D correctly simulated by H cannot possibly reach past its own
>>>>>>>>>>> line 06
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> So, you are just showing that you aren't actually interested
>>>>>>>>>> in Honest Dialog, because you keep shifting to your Dishonest
>>>>>>>>>> Strawman.
>>>>>>>>>
>>>>>>>>> No one can possibly provide the exact sequence of D
>>>>>>>>> correctly simulated by H that differs from the above
>>>>>>>>> sequence *thus proving that is it correct*
>>>>>>>>
>>>>>>>
>>>>>>> You didn't provide a line-by-line execution trace of D correctly
>>>>>>> simulated by H that provides the exact sequence of the line numbers
>>>>>>> of D showing the exact sequence of steps of this simulation.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> In other words, you aren't actually interested in an answer,
>>>>>
>>>>> A correct rebuttal of the above has a single form everything
>>>>> else is merely double-talk.
>>>>>
>>>>> *If you say that my trace is wrong then you can either provide*
>>>>> *the correct trace or utterly fail to provide any rebuttal*
>>>>>
>>>>>
>>>>
>>>> In other words you are just admitting
>>>
>>> That you refuse to provide a proper rebuttal because you
>>> already know that I am correct and there is no proper rebuttal.
>>>
>> You failed to provide a proper rebuttal to Linz because you already
>> know he is correct and there is no propre rebuttal.
>
> Changing the subject instead of providing the exactly correct sequence
> of line numbers of D correctly simulated by H is simply a dishonest
> dodge.
>
Changing the subject instead of providing a proof that H solves the
halting problem is simply a dishonest dodge.

On 1/13/2024 6:09 AM, immibis wrote:
> On 1/12/24 19:50, olcott wrote:
>> On 1/12/2024 10:37 AM, immibis wrote:
>>> On 1/12/24 17:17, olcott wrote:
>>>> On 1/12/2024 6:30 AM, Richard Damon wrote:
>>>>> On 1/11/24 11:31 PM, olcott wrote:
>>>>>> On 1/11/2024 10:08 PM, Richard Damon wrote:
>>>>>>> On 1/11/24 10:41 PM, olcott wrote:
>>>>>>>> On 1/11/2024 9:34 PM, Richard Damon wrote:
>>>>>>>>> On 1/11/24 10:16 PM, olcott wrote:
>>>>>>>>>> On 1/11/2024 9:01 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/11/24 2:52 PM, olcott wrote:
>>>>>>>>>>>> No one can possibly provide the exact sequence of D correctly
>>>>>>>>>>>> simulated by H that differs from the one provided below.
>>>>>>>>>>>>
>>>>>>>>>>>> *Every rebuttal has always been the pure bluster of dogma*
>>>>>>>>>>>> *with zero supporting exact execution trace*
>>>>>>>>>>>>
>>>>>>>>>>>> 04 int D(ptr x)
>>>>>>>>>>>> 05 {
>>>>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>>>>> 09   return Halt_Status;
>>>>>>>>>>>> 10 }
>>>>>>>>>>>> 11
>>>>>>>>>>>> 12 void main()
>>>>>>>>>>>> 13 {
>>>>>>>>>>>> 14   H(D,D);
>>>>>>>>>>>> 15 }
>>>>>>>>>>>>
>>>>>>>>>>>> *Execution Trace*
>>>>>>>>>>>> Line 14: main() invokes H(D,D);
>>>>>>>>>>>>
>>>>>>>>>>>> *keeps repeating* (unless aborte
>>>>>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that
>>>>>>>>>>>> simulates D(D)
>>>>>>>>>>>>
>>>>>>>>>>>> *Simulation invariant*
>>>>>>>>>>>> D correctly simulated by H cannot possibly reach past its
>>>>>>>>>>>> own line 06
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> So, you are just showing that you aren't actually interested
>>>>>>>>>>> in Honest Dialog, because you keep shifting to your Dishonest
>>>>>>>>>>> Strawman.
>>>>>>>>>>
>>>>>>>>>> No one can possibly provide the exact sequence of D
>>>>>>>>>> correctly simulated by H that differs from the above
>>>>>>>>>> sequence *thus proving that is it correct*
>>>>>>>>>
>>>>>>>>
>>>>>>>> You didn't provide a line-by-line execution trace of D correctly
>>>>>>>> simulated by H that provides the exact sequence of the line numbers
>>>>>>>> of D showing the exact sequence of steps of this simulation.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> In other words, you aren't actually interested in an answer,
>>>>>>
>>>>>> A correct rebuttal of the above has a single form everything
>>>>>> else is merely double-talk.
>>>>>>
>>>>>> *If you say that my trace is wrong then you can either provide*
>>>>>> *the correct trace or utterly fail to provide any rebuttal*
>>>>>>
>>>>>>
>>>>>
>>>>> In other words you are just admitting
>>>>
>>>> That you refuse to provide a proper rebuttal because you
>>>> already know that I am correct and there is no proper rebuttal.
>>>>
>>> You failed to provide a proper rebuttal to Linz because you already
>>> know he is correct and there is no propre rebuttal.
>>
>> Changing the subject instead of providing the exactly correct sequence
>> of line numbers of D correctly simulated by H is simply a dishonest
>> dodge.
>>
> Changing the subject instead of providing a proof that H solves the
> halting problem is simply a dishonest dodge.

When I focus on one step of this proof trying to get closure
on this step and you change the subject to something else this
IS A DISHONEST DODGE.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 1/13/24 11:41 AM, olcott wrote:
> On 1/13/2024 6:09 AM, immibis wrote:
>> On 1/12/24 19:50, olcott wrote:
>>> On 1/12/2024 10:37 AM, immibis wrote:
>>>> On 1/12/24 17:17, olcott wrote:
>>>>> On 1/12/2024 6:30 AM, Richard Damon wrote:
>>>>>> On 1/11/24 11:31 PM, olcott wrote:
>>>>>>> On 1/11/2024 10:08 PM, Richard Damon wrote:
>>>>>>>> On 1/11/24 10:41 PM, olcott wrote:
>>>>>>>>> On 1/11/2024 9:34 PM, Richard Damon wrote:
>>>>>>>>>> On 1/11/24 10:16 PM, olcott wrote:
>>>>>>>>>>> On 1/11/2024 9:01 PM, Richard Damon wrote:
>>>>>>>>>>>> On 1/11/24 2:52 PM, olcott wrote:
>>>>>>>>>>>>> No one can possibly provide the exact sequence of D correctly
>>>>>>>>>>>>> simulated by H that differs from the one provided below.
>>>>>>>>>>>>>
>>>>>>>>>>>>> *Every rebuttal has always been the pure bluster of dogma*
>>>>>>>>>>>>> *with zero supporting exact execution trace*
>>>>>>>>>>>>>
>>>>>>>>>>>>> 04 int D(ptr x)
>>>>>>>>>>>>> 05 {
>>>>>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>>>>>> 09   return Halt_Status;
>>>>>>>>>>>>> 10 }
>>>>>>>>>>>>> 11
>>>>>>>>>>>>> 12 void main()
>>>>>>>>>>>>> 13 {
>>>>>>>>>>>>> 14   H(D,D);
>>>>>>>>>>>>> 15 }
>>>>>>>>>>>>>
>>>>>>>>>>>>> *Execution Trace*
>>>>>>>>>>>>> Line 14: main() invokes H(D,D);
>>>>>>>>>>>>>
>>>>>>>>>>>>> *keeps repeating* (unless aborte
>>>>>>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that
>>>>>>>>>>>>> simulates D(D)
>>>>>>>>>>>>>
>>>>>>>>>>>>> *Simulation invariant*
>>>>>>>>>>>>> D correctly simulated by H cannot possibly reach past its
>>>>>>>>>>>>> own line 06
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> So, you are just showing that you aren't actually interested
>>>>>>>>>>>> in Honest Dialog, because you keep shifting to your
>>>>>>>>>>>> Dishonest Strawman.
>>>>>>>>>>>
>>>>>>>>>>> No one can possibly provide the exact sequence of D
>>>>>>>>>>> correctly simulated by H that differs from the above
>>>>>>>>>>> sequence *thus proving that is it correct*
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You didn't provide a line-by-line execution trace of D correctly
>>>>>>>>> simulated by H that provides the exact sequence of the line
>>>>>>>>> numbers
>>>>>>>>> of D showing the exact sequence of steps of this simulation.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> In other words, you aren't actually interested in an answer,
>>>>>>>
>>>>>>> A correct rebuttal of the above has a single form everything
>>>>>>> else is merely double-talk.
>>>>>>>
>>>>>>> *If you say that my trace is wrong then you can either provide*
>>>>>>> *the correct trace or utterly fail to provide any rebuttal*
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> In other words you are just admitting
>>>>>
>>>>> That you refuse to provide a proper rebuttal because you
>>>>> already know that I am correct and there is no proper rebuttal.
>>>>>
>>>> You failed to provide a proper rebuttal to Linz because you already
>>>> know he is correct and there is no propre rebuttal.
>>>
>>> Changing the subject instead of providing the exactly correct sequence
>>> of line numbers of D correctly simulated by H is simply a dishonest
>>> dodge.
>>>
>> Changing the subject instead of providing a proof that H solves the
>> halting problem is simply a dishonest dodge.
>
> When I focus on one step of this proof trying to get closure
> on this step and you change the subject to something else this
> IS A DISHONEST DODGE.
>

Then why don't you go back to the begining has handle the questions that
cme up before this.

YOUR step is based on false premises, so it would be incorrect to deal
with the incorrect question.

YOU are showing that you are just engaged in a dishonest dodge.

Since you can't get to this step, it doesn't need to be answered.