Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD)

On 5/9/25 11:13 PM, olcott wrote:

On 5/9/2025 9:40 PM, Keith Thompson wrote:

olcott <polcott333@gmail.com> writes:

On 5/9/2025 4:40 PM, Richard Heathfield wrote:

On 09/05/2025 21:15, olcott wrote:

On 5/9/2025 3:07 PM, Richard Heathfield wrote:

On 09/05/2025 20:46, olcott wrote:

We have not begun to get into any of those points.
We are only asking can DDD correctly simulated
by any HHH that can exist ever reach its own
"return" instruction.

>
DDD can't be correctly simulated by itself (which is effectively
what you're trying to do when you fire up the simulation from
inside DDD).

>
How the Hell did you twist my words to say that?

I haven't touched your words. What I have done is to observe that
DDD's /only/ action is to call a simulator. Since DDD isn't itself a
simulator, there is nothing to simulate except a call to a
simulator.
It's recursion without a base case - a rookie error.
HHH cannot successfully complete its task, because it never regains
control after the first recursion. To return, it must abort the
simulation, which means the simulation fails.
>

void DDD()
{
    HHH(DDD);
    return;
}
>
When 1 or more statements of DDD are correctly
simulated by HHH then this correctly simulated
DDD cannot possibly reach its own “return statement”.

On what grounds can you persuade an extraordinarily sceptical
readership that HHH 'correctly simulated' DDD?

>
Any competent C programmer can see that
the call from DDD to HHH(DDD) (its own simulator)
is equivalent to infinite recursion.
>
On 5/8/2025 8:30 PM, Keith Thompson wrote:

Assuming that HHH(DDD) "correctly simulates" DDD, and assuming it
does nothing else, your code would be equivalent to this:
>
      void DDD(void) {
          DDD();
          return;
      }
>
Then the return statement (which is unnecessary anyway) will never be
reached.  In practice, the program will likely crash due to a stack
overflow, unless the compiler implements tail-call optimization, in
which case the program might just run forever -- which also means the
unnecessary return statement will never be reached.

>
I had not intended to post again, but I feel the need to make
a clarification.
>
I acknowledged that the return statement would never be reached
*given the assumption* that HHH correctly simulates DDD.  Given
that assumption, a call to DDD() should be equivalent to a call
to HHH(DDD).
>

 Yes and then I moved on the next tiny incremental
step of my proof. Correctly simulated less than
an infinite number of instructions does not help
the simulated DDD to reach its "return statement"
final halt state.

Sure it does, as "the simulated DDD" has its behavior defined by UTM(DDD) not the partial simulation done withing HHH(DDD).
Your attempt to redefine the behavior is just your lying by strawman,

 

I did not address whether the assumption is valid.  I merely
temporarily accepted it for the sake of discussion, just as I would
accept that if I were ten feet tall I would bump my head against
the ceiling in my house.
>
The discussion I had with olcott did not reach the point of
discussing *how* HHH could correctly simulate DDD, or whether it
would even be logically possible for it to do so.

 Right this takes a glimmering of understanding of
the x86 language. The x86 language it needed to
get an exactly precise understanding of the control
flow of DDD as directed graph state transition
diagram.

Right, and that says that DDD() will halt when correct simulated, as the x86 langugage doesn't allow stopping that analysis until it reaches a final state.
That HHH stops its emulation doesn't affect the behavior as defined by the x86 language.

 

I also did not
address any issues of partial simulation, where olcott claims that
HHH can "accurately simulate" only a few x86 instructions rather
than simulating its entire execution.

 

I did not participate in
any discussion that would require knowledge of x86 machine or
assembly code.  (I have no doubt that I could learn x86 machine
and assembly code reasonably well if motivated to do so, but I am
not so motivated.)
>
What I acknowledged was barely more than "if HHH correctly simulates
DDD, then HHH correctly simulates DDD".

 No much more than this you acknowledged that
when DDD is correctly simulated by HHH that
the simulated DDD cannot possibly reach its
own "return statement" (final halt state)

But it isn't.
No partial simulation is a "correct simulation" as that term is define to mean the simulation of *ALL* the insturcitons of the program.
Stopping before getting to the end is not going to the end.

 This is very important to computer science because
non-termination is entirely measured by the impossibility
of reaching a final halt state.

Right, but only under the condition of unbounded running/simulating. Not reaching the end after only a given finite number of steps is NOT the definition of non-halting.

  From all of the we know that when HHH(DDD) reports
on the behavior of its correct simulation of its input
that it can correctly reject this input as not
specifying a sequence of configurations that halts.

No, as has been shown, it doesn't do a "correct simulation" and thus your premise is incorrect.
The fact that you have also admitted that neither your HHH or DDD are actually programs as defined by the field but just "C functions" means you have admttted that you whole arguement is one giant Caterogry error.

 

(My understanding from
posts by others, whom I presume to be sufficiently knowledgeable,
is that HHH logically cannot accurately simulate DDD.)  I would
prefer that olcott refrain from using my words to support any of
his arguments beyond the scope of what he and I directly discussed.
>

 Can we proceed to the next tiny increment of scope?
 When one or more statements of DDD are correctly
simulated by HHH the correctly simulated DDD still
cannot possibly reach its own "return" statement.

Which is irrelevent, and each DDD of that set is a different input, as you can't actually emulate DDD past the call HHH until you have paired it with the exact HHH it calls, and since each of your HHHs are different partial emulators, and each of them is given the DDD that has been complete by being paired with them, every one of your cases is looking at a different input.

 This is trivial. When an infinite number of steps
of correct simulation are not enough we can conclude
that less than an infinite number of steps is also
insufficient.

WHich agian is a different input, so say nothing about the behavior of the input of the ones that did a finite simulation.

 That was the tiny increment of scope. Now I
show why that was important.
 

Because it is built on a lie and unsound logic.

 It is a fact that when HHH rejects its input
DDD as specifying a non-halting sequence of
configurations on the basis of the behavior
of DDD correctly simulated by HHH, that HHH
is necessary correct.

Nope, it just shows you are a liar that ignores the errors pointed out in your logic, apparently because either you know you are lying and don't care, or ate just too stupid to understand the error or to be able to learn how to do it better.

 If you pay 100% complete attention and make
sure to totally ignore mere rhetoric as any
possible correct rebuttal you will find that
 every "rebuttal" either commits the strawman
error changing my words and then rebutting the
changed words or simply dodges by attempting
to change the subject.

No, if you would look, you would see that all you claims have been shown to be in error, and you have no actual basis to make your claims.

 There has been no actual rebuttal of these
exact words:

Sure there have been, you are just showing that you are just a pathological liar that is incapable of understanding the truth.

 It is a fact that when HHH rejects its input
DDD as specifying a non-halting sequence of
configurations on the basis of the behavior
of DDD correctly simulated by HHH, that HHH
is necessary correct.
 They always either change the words or change
the subject.
 

No, the problem is your words are just illogical gobbldy-gook based on equivocation, contradictions and lies.
Until you actually handle the errors pointed out, it can be assumed that you have no actual logical basis to make you claims, and just don't care aobut that fact, as truth doesn't mean anything to you.