On 8/9/25 8:51 PM, olcott wrote:

On 8/9/2025 7:26 PM, wij wrote:

olcott has always changed his POO Problem 'silently' from
H(D)=0,1,both,...
This time, HHH(DD)==0 is correct is just another circle (run out of
option)
Each change takes about a coupe of months, silently.
The point is that each time the new answer contradicts the previous one.
He had to lie. So, be warned, you are debating with a liar.

It may seem that way until you understand that a
Turing machine is not allowed to report on the
behavior of another Turing machine.

And where do you get that from?

Because of very extensive indoctrination it may
be very difficult to see this.

No, your self-indoctrination with your lies makes you think this.

I guess you are just admitting the Halting Problem is proved because you
just can't make a Turing Machine that could possible answer the question
for ANY machine.

WHich just shows your idea of Computation Theory is exceedingly weak and useless.

How do you think computers do what you ask them to? Remember, they just
work with bits set to 1s and 0s, no "letters" or "numbers" or "pictures"
or "videos".

How does your AI machines give the answers they do? Because computations
are based on using representations, and thus CAN be responsible for the behavior of programs, as programs CAN be properly represented so they
can be correctly simulated.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/9/25 9:03 PM, olcott wrote:

On 8/9/2025 7:54 PM, dbush wrote:

On 8/9/2025 8:51 PM, olcott wrote:

On 8/9/2025 7:26 PM, wij wrote:

olcott has always changed his POO Problem 'silently' from
H(D)=0,1,both,...
This time, HHH(DD)==0 is correct is just another circle (run out of
option)
Each change takes about a coupe of months, silently.
The point is that each time the new answer contradicts the previous
one.
He had to lie. So, be warned, you are debating with a liar.

It may seem that way until you understand that a
Turing machine is not allowed to report on the
behavior of another Turing machine.

Likewise, a Turing machine is not allowed to report on the values of
actual numbers because a Turing machine cannot take actual numbers as
input, only finite strings.

Agreed?

Yes that is correct.

So stop using computers to do that!!!

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞,
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

The key missing piece is that the behavior of
⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by Ĥ.embedded_H is
different than the behavior of Ĥ applied to ⟨Ĥ⟩

No it isn't.

You are just using a LIE as your definition of "Correct Simulation", as
well as you normally aren't using the right definition of a Program.

And, you lost that definition of behavior of the input, since you
haven't actually shown its definition in the past week, which also means
you need to define what you mean by "correct simulation by the decider",
and even what you mean by "the input"

Your problem with canceling out everything old is that you canceled out everything old and need to start again at the begining, and PROVE your
claims.

Three LLM systems agree that the behavior of
DD correctly simulated by HHH is not the same
as the behavior of the directly executed DD().

https://claude.ai/share/da9e56ba-f4e9-45ee-9f2c-dc5ffe10f00c

https://chatgpt.com/share/68939ee5-e2f8-8011-837d-438fe8e98b9c

https://grok.com/share/c2hhcmQtMg%3D%3D_810120bb-5ab5-4bf8-af21-
eedd0f09e141

Which all were based on the same erroneous input that implied that HHH
*WILL* either find a non-halting pattern or reach the end, and *WILL*
return a result.

Starting with that false start just makes the results invalid.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 10/08/2025 01:51, olcott wrote:

On 8/9/2025 7:26 PM, wij wrote:

olcott has always changed his POO Problem 'silently' from
H(D)=0,1,both,...
This time, HHH(DD)==0 is correct is just another circle (run
out of option)
Each change takes about a coupe of months, silently.
The point is that each time the new answer contradicts the
previous one.
He had to lie. So, be warned, you are debating with a liar.

It may seem that way until you understand that a
Turing machine is not allowed to report on the
behavior of another Turing machine.

"not allowed"?!?

By whom?

--
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/10/25 12:21 AM, olcott wrote:

On 8/9/2025 8:09 PM, dbush wrote:

On 8/9/2025 9:03 PM, olcott wrote:

On 8/9/2025 7:54 PM, dbush wrote:

On 8/9/2025 8:51 PM, olcott wrote:

On 8/9/2025 7:26 PM, wij wrote:

olcott has always changed his POO Problem 'silently' from
H(D)=0,1,both,...
This time, HHH(DD)==0 is correct is just another circle (run out
of option)
Each change takes about a coupe of months, silently.
The point is that each time the new answer contradicts the
previous one.
He had to lie. So, be warned, you are debating with a liar.

It may seem that way until you understand that a
Turing machine is not allowed to report on the
behavior of another Turing machine.

Likewise, a Turing machine is not allowed to report on the values of
actual numbers because a Turing machine cannot take actual numbers
as input, only finite strings.

Agreed?

Yes that is correct.

Good.

int sum(int x, int y)
{
    return (x+2)+(y+3);
}

Giving the above sum, it is incorrect for sum(2,3) to report the sum
of 2+3 because those are not the values the input specifies.  Turing
machines can only compute the values that its actual input actually
specifies.

Therefore sum(2,3) correctly reports the sum of 4+6 because those are
the values its actual input actually specifies.  Specifically, the
finite string "2" specifies the value 4 for the first parameter and
the finite string "3" specifies the value 6 for the second parameter.

Agreed?

Yes this is correct.

So, programs can look at the semantic meaning of their inputs, and not
just the raw symbols that are there.

After all, the 2 and 3 above are just meanings assigned to patterns of
bits in the memory, and not the only meaning they could have.

Just like the bit pattern for the code of DD represents the program that
was compiled to form it. Of course, it needs to have ALL the code of
that, but since the actual input is just a value that represents the
starting address for the program, the input automatically expands to
include all of the memory accessed in the simulation.

Thus, you claim that Turing Machines can't answer about the behavior of
another Turing Machine is shown incorrect, if you say that it can
compute 2+3.

Sorry, you are just showing that your world is just based on lies,
deceit, category errors, and self-contradictions.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/10/25 12:15 PM, olcott wrote:

On 8/10/2025 10:50 AM,    wrote:

On 8/10/2025 11:17 AM, olcott wrote:

To are delving too far off-topic.

Not at all.  I'm demonstrating that finite strings must be defined to
have a single specific meaning, otherwise determining what is right
and what is wrong is futile.

_DD()
[00002162] 55             push ebp
[00002163] 8bec           mov ebp,esp
[00002165] 51             push ecx
[00002166] 6862210000     push 00002162 // push DD
[0000216b] e862f4ffff     call 000015d2 // call HHH
[00002170] 83c404         add esp,+04
[00002173] 8945fc         mov [ebp-04],eax
[00002176] 837dfc00       cmp dword [ebp-04],+00
[0000217a] 7402           jz 0000217e
[0000217c] ebfe           jmp 0000217c
[0000217e] 8b45fc         mov eax,[ebp-04]
[00002181] 8be5           mov esp,ebp
[00002183] 5d             pop ebp
[00002184] c3             ret
Size in bytes:(0035) [00002184]

Then you must acknowledge that DD emulated
by HHH according to the definition of the x86
language cannot possibly reach its own "ret"
instruction final halt state.

Nope, because your HHH doesn't do that, s your statement is just a lie.

Yom might be able to say that for DD' like the above but based on a HHH'
that DOES a correct simulation of its input that HHH'(DD') will not
halt, but then that HHH' isn't a decider.

The fact that they are different programs and inputs just means you
can't compare the two except by lying, which you do.

When you understand this we can move on to the
next step of my proof. I am not interested in
delving off into tangents not directly related
to this proof.

Maybe you need to spend some time to learn the meaning of the words you use.

Like how the input needs to be a complete and correct representation of
the PROGRAM DD, which means it includes the code of the HHH that it
uses, and thus only represents ONE version of your template based on a
specific HHH, and thus you can't look at a different one.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)