On 3/14/22 9:37 PM, olcott wrote:
> On 3/12/2022 9:59 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>
>> I've shown you how to write Linz's conditions in terms of simulation:
>>
>>    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞  if UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts, and
>>    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn    if UTM(Ĥ⟩ ⟨Ĥ⟩) does not halt.
>>
>> Feel fee to replace "halts" with "would reach its final state" (and
>> similarly for "does not halt") if it make you feel better.  Both figures
>> of speech convey the same mathematical fact, but one is shorter and fits
>> on a line.
>>
>> What you can't do, if you want to keep talking about what Linz is
>> talking about, is replace the reference to a UTM with embedded_H.
>
> Embedded_H has a full UTM as a part of it. The Linz ⊢* wild card state
> transition allows for a UTM simulation to be a part of the decision
> process.
>

No, it CAN'T be if it aborts its simulation. That is a CONTRADICTION by
definition.

embedded_H can be EITHER a UTM, or it can abort its simulation.

> Embedded_H determines whether or not its simulated input would ever
> reach its final state if embedded_H remained in pure UTM mode.

Which is a false premise, and thus unsound logic.

It needs to determine what the CORRECT simulation of its input would do
if the copy of embedded_H does what embedded_H actually does.

You ar just basing your proof an a blatent lie.

>
>>> It <is> the case that the correct pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by the
>>> copy of H embedded within Ĥ would never reach the final state of this
>>> input ⟨Ĥ⟩.qn.
>>
>> Irrelevant.  What matters is what follows logically from Linz's
>> definition of a halt decider.  If you think there is any point, I'll
>> write it out again for you in terms of UTMs.
>>
>
> If the input to embedded_H never halts and embedded_H correctly reports
> this that is most relevant.
>
>

Except that if embedded_H reports that its input doesn't halt, then the
H^ that it is embedded in Halts, thus H^ applied to <H^> will ALWAYS
halt if embedded_H says it doesn't, so embedded_H is ALWAYS wrong to say
that <H^> <H^> is the representation of a non-halting computation.

FAIL.

On 3/14/22 9:40 PM, olcott wrote:
> On 3/14/2022 8:34 PM, André G. Isaak wrote:
>> On 2022-03-14 19:17, olcott wrote:
>>> On 3/12/2022 8:30 PM, André G. Isaak wrote:
>>
>>>> The exact same string $ might encode a Turing Machine when passed to
>>>> one Turing Machine, an algebraic equation when passed to another TM,
>>>> and a line of Old Church Slavonic written in Glogolitic to a third.
>>>>
>>>
>>> None-the-less when a BASIC interpreter is running a BASIC program or
>>> a simulating halt decider with UTM functionality is simulating a
>>> Turing machine description in each of these two cases their input
>>> would either reach or fail to reach a final state.
>>
>> The input to a BASIC interpreter is a string representing a BASIC
>> program. The BASIC program might do any number of things including
>> reaching the end of the program, but the string itself does not do
>> these things.
>>
>
> The interpreted BASIC program does run and the simulated Turing machine
> description does have final states.
>

Which it reaches if the Halt Decider says it won't halt, so the Halt
Decider is wrong.

It doesn't matter that the 'broken' simulation by H never reached it,
what matters is if the ACTUAL running of it dods.

On 3/14/2022 8:46 PM, André G. Isaak wrote:
> On 2022-03-14 19:40, olcott wrote:
>> On 3/14/2022 8:34 PM, André G. Isaak wrote:
>>> On 2022-03-14 19:17, olcott wrote:
>>>> On 3/12/2022 8:30 PM, André G. Isaak wrote:
>>>
>>>>> The exact same string $ might encode a Turing Machine when passed
>>>>> to one Turing Machine, an algebraic equation when passed to another
>>>>> TM, and a line of Old Church Slavonic written in Glogolitic to a
>>>>> third.
>>>>>
>>>>
>>>> None-the-less when a BASIC interpreter is running a BASIC program or
>>>> a simulating halt decider with UTM functionality is simulating a
>>>> Turing machine description in each of these two cases their input
>>>> would either reach or fail to reach a final state.
>>>
>>> The input to a BASIC interpreter is a string representing a BASIC
>>> program. The BASIC program might do any number of things including
>>> reaching the end of the program, but the string itself does not do
>>> these things.
>>>
>>
>> The interpreted BASIC program does run and the simulated Turing
>> machine description does have final states.
>
> The interpreted BASIC program is not the same thing as the string which
> is the input to the BASIC interpreter. It's what happens *inside* the
> interpreter. You don't seem to grasp what "string" means.
>

That ⟨Ĥ⟩ ⟨Ĥ⟩ finite strings specify non-halting behavior when correctly
simulated by the UTM within embedded_H is the same as these finite
strings specifying non-halting behavior when correctly interpreted by a
BASIC in interpreter.

10 PRINT "Hello, World!"
20 goto 10
30 END

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 2022-03-14 20:02, olcott wrote:

<snip nonresponsive post>

Again, I'll repeat the question which you dishonestly snipped rather
than answering. I won't bother putting it in all caps or repeating it
five times.

How does one encode Ĥ applied to ⟨Ĥ⟩ as a string which can be passed to
Ĥ if that computation is in fact different from ⟨Ĥ⟩ ⟨Ĥ⟩?

If there are computations which cannot be encoded as strings, then it is
impossible to design a universal halt decider since that means there are
computations which it cannot be asked about.

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

On 3/14/22 10:02 PM, olcott wrote:
> On 3/14/2022 8:46 PM, André G. Isaak wrote:
>> On 2022-03-14 19:40, olcott wrote:
>>> On 3/14/2022 8:34 PM, André G. Isaak wrote:
>>>> On 2022-03-14 19:17, olcott wrote:
>>>>> On 3/12/2022 8:30 PM, André G. Isaak wrote:
>>>>
>>>>>> The exact same string $ might encode a Turing Machine when passed
>>>>>> to one Turing Machine, an algebraic equation when passed to
>>>>>> another TM, and a line of Old Church Slavonic written in
>>>>>> Glogolitic to a third.
>>>>>>
>>>>>
>>>>> None-the-less when a BASIC interpreter is running a BASIC program
>>>>> or a simulating halt decider with UTM functionality is simulating a
>>>>> Turing machine description in each of these two cases their input
>>>>> would either reach or fail to reach a final state.
>>>>
>>>> The input to a BASIC interpreter is a string representing a BASIC
>>>> program. The BASIC program might do any number of things including
>>>> reaching the end of the program, but the string itself does not do
>>>> these things.
>>>>
>>>
>>> The interpreted BASIC program does run and the simulated Turing
>>> machine description does have final states.
>>
>> The interpreted BASIC program is not the same thing as the string
>> which is the input to the BASIC interpreter. It's what happens
>> *inside* the interpreter. You don't seem to grasp what "string" means.
>>
>
> That ⟨Ĥ⟩ ⟨Ĥ⟩ finite strings specify non-halting behavior when correctly
> simulated by the UTM within embedded_H is the same as these finite
> strings specifying non-halting behavior when correctly interpreted by a
> BASIC in interpreter.
>
> 10 PRINT "Hello, World!"
> 20 goto 10
> 30 END
>

No, because we have SHOWN that, if H applied to <H^> <H^> goes to H.Qn,
that the actual simulation by an ACTUAL UTM halts, because H^ will go to
H^.Qn and halt if the H embedded in it goes to H.Qn.

You have only show traces based on a H that is either broken in that it
NEVER answer the question H applied to <H^> <H^>, or is incorrect,
because it makes an error in its simulation, and forgets that the copy
of H in H^ will do the same thing as it does.

You can't argue with the actual running of the program!!!

You make the mistake that your H needs to be JUST a program, while you
actually seem to put a person in the loop to change which H you are
using in the middle, which means you never had 'AN' H to test.

You H suffers from schizophrenia, which is a malady that computer
programs can't have (they can try to fake it, but they are
deterministic, so they have a definite behavior).

FAIL.

On 3/14/2022 9:05 PM, André G. Isaak wrote:
> On 2022-03-14 20:02, olcott wrote:
>
> <snip nonresponsive post>
>
> Again, I'll repeat the question which you dishonestly snipped rather
> than answering. I won't bother putting it in all caps or repeating it
> five times.
>
> How does one encode Ĥ applied to ⟨Ĥ⟩ as a string which can be passed to
> Ĥ if that computation is in fact different from ⟨Ĥ⟩ ⟨Ĥ⟩?
>

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

The ⟨Ĥ⟩ ⟨Ĥ⟩ above is inherently exactly one level of indirect reference
away from Ĥ ⟨Ĥ⟩ above, thus making it utterly impossible to pass this
exact same Ĥ ⟨Ĥ⟩ as an input to embedded_H.

> If there are computations which cannot be encoded as strings, then it is
> impossible to design a universal halt decider since that means there are
> computations which it cannot be asked about.
>
> André
>

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 2022-03-14 21:07, olcott wrote:
> On 3/14/2022 9:05 PM, André G. Isaak wrote:
>> On 2022-03-14 20:02, olcott wrote:
>>
>> <snip nonresponsive post>
>>
>> Again, I'll repeat the question which you dishonestly snipped rather
>> than answering. I won't bother putting it in all caps or repeating it
>> five times.
>>
>> How does one encode Ĥ applied to ⟨Ĥ⟩ as a string which can be passed
>> to Ĥ if that computation is in fact different from ⟨Ĥ⟩ ⟨Ĥ⟩?
>>
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> The ⟨Ĥ⟩ ⟨Ĥ⟩ above is inherently exactly one level of indirect reference
> away from Ĥ ⟨Ĥ⟩ above, thus making it utterly impossible to pass this
> exact same Ĥ ⟨Ĥ⟩ as an input to embedded_H.

There are no 'levels of indirection' when discussing Turing Machines.

If there is no way to encode Ĥ ⟨Ĥ⟩ such that it can be given as an input
to your decider, then your decider is broken since it must be able to
provide an answer for *every* computation, including Ĥ ⟨Ĥ⟩.

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

On 3/14/2022 11:04 PM, André G. Isaak wrote:
> On 2022-03-14 21:07, olcott wrote:
>> On 3/14/2022 9:05 PM, André G. Isaak wrote:
>>> On 2022-03-14 20:02, olcott wrote:
>>>
>>> <snip nonresponsive post>
>>>
>>> Again, I'll repeat the question which you dishonestly snipped rather
>>> than answering. I won't bother putting it in all caps or repeating it
>>> five times.
>>>
>>> How does one encode Ĥ applied to ⟨Ĥ⟩ as a string which can be passed
>>> to Ĥ if that computation is in fact different from ⟨Ĥ⟩ ⟨Ĥ⟩?
>>>
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> The ⟨Ĥ⟩ ⟨Ĥ⟩ above is inherently exactly one level of indirect
>> reference away from Ĥ ⟨Ĥ⟩ above, thus making it utterly impossible to
>> pass this exact same Ĥ ⟨Ĥ⟩ as an input to embedded_H.
>
> There are no 'levels of indirection' when discussing Turing Machines.
>
> If there is no way to encode Ĥ ⟨Ĥ⟩ such that it can be given as an input
> to your decider, then your decider is broken since it must be able to
> provide an answer for *every* computation, including Ĥ ⟨Ĥ⟩.
>
> André
>

There is no way for any Turing machine to have its actual self as input.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 2022-03-14 22:09, olcott wrote:
> On 3/14/2022 11:04 PM, André G. Isaak wrote:
>> On 2022-03-14 21:07, olcott wrote:
>>> On 3/14/2022 9:05 PM, André G. Isaak wrote:
>>>> On 2022-03-14 20:02, olcott wrote:
>>>>
>>>> <snip nonresponsive post>
>>>>
>>>> Again, I'll repeat the question which you dishonestly snipped rather
>>>> than answering. I won't bother putting it in all caps or repeating
>>>> it five times.
>>>>
>>>> How does one encode Ĥ applied to ⟨Ĥ⟩ as a string which can be passed
>>>> to Ĥ if that computation is in fact different from ⟨Ĥ⟩ ⟨Ĥ⟩?
>>>>
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> The ⟨Ĥ⟩ ⟨Ĥ⟩ above is inherently exactly one level of indirect
>>> reference away from Ĥ ⟨Ĥ⟩ above, thus making it utterly impossible to
>>> pass this exact same Ĥ ⟨Ĥ⟩ as an input to embedded_H.
>>
>> There are no 'levels of indirection' when discussing Turing Machines.
>>
>> If there is no way to encode Ĥ ⟨Ĥ⟩ such that it can be given as an
>> input to your decider, then your decider is broken since it must be
>> able to provide an answer for *every* computation, including Ĥ ⟨Ĥ⟩.
>>
>> André
>>
>
> There is no way for any Turing machine to have its actual self as input.

Well, yes, that follows trivially from the fact that Turing Machines
don't take Turing Machines as inputs - a fact which seems to fascinate
you for whatever reason.

But a Turing Machine X *can* be given as its input a *description* of a
computation involving X applied to input I, in which case X must be able
to answer about X applied to input I; which using natural language
idioms would be "itself" applied to input I.

If X is a TM which takes a description of any computation as its input,
it *must* be possible to encode X applied to I in a way that allows it
to be given to X as an input.

This is really quite basic.

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

On 3/14/22 11:07 PM, olcott wrote:
> On 3/14/2022 9:05 PM, André G. Isaak wrote:
>> On 2022-03-14 20:02, olcott wrote:
>>
>> <snip nonresponsive post>
>>
>> Again, I'll repeat the question which you dishonestly snipped rather
>> than answering. I won't bother putting it in all caps or repeating it
>> five times.
>>
>> How does one encode Ĥ applied to ⟨Ĥ⟩ as a string which can be passed
>> to Ĥ if that computation is in fact different from ⟨Ĥ⟩ ⟨Ĥ⟩?
>>
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> The ⟨Ĥ⟩ ⟨Ĥ⟩ above is inherently exactly one level of indirect reference
> away from Ĥ ⟨Ĥ⟩ above, thus making it utterly impossible to pass this
> exact same Ĥ ⟨Ĥ⟩ as an input to embedded_H.

Why?

By definition of the Hlating Problem, H is supposed to be able to take
as input ANY computation and decide on it.

You claim basically just PROVES that such an H can not exist, as there
is a computation that H can not answer about.

ALL means ALL, not 'most'

>
>
>> If there are computations which cannot be encoded as strings, then it
>> is impossible to design a universal halt decider since that means
>> there are computations which it cannot be asked about.
>>
>> André
>>
>
>

On 3/15/22 12:09 AM, olcott wrote:
> On 3/14/2022 11:04 PM, André G. Isaak wrote:
>> On 2022-03-14 21:07, olcott wrote:
>>> On 3/14/2022 9:05 PM, André G. Isaak wrote:
>>>> On 2022-03-14 20:02, olcott wrote:
>>>>
>>>> <snip nonresponsive post>
>>>>
>>>> Again, I'll repeat the question which you dishonestly snipped rather
>>>> than answering. I won't bother putting it in all caps or repeating
>>>> it five times.
>>>>
>>>> How does one encode Ĥ applied to ⟨Ĥ⟩ as a string which can be passed
>>>> to Ĥ if that computation is in fact different from ⟨Ĥ⟩ ⟨Ĥ⟩?
>>>>
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> The ⟨Ĥ⟩ ⟨Ĥ⟩ above is inherently exactly one level of indirect
>>> reference away from Ĥ ⟨Ĥ⟩ above, thus making it utterly impossible to
>>> pass this exact same Ĥ ⟨Ĥ⟩ as an input to embedded_H.
>>
>> There are no 'levels of indirection' when discussing Turing Machines.
>>
>> If there is no way to encode Ĥ ⟨Ĥ⟩ such that it can be given as an
>> input to your decider, then your decider is broken since it must be
>> able to provide an answer for *every* computation, including Ĥ ⟨Ĥ⟩.
>>
>> André
>>
>
> There is no way for any Turing machine to have its actual self as input.
>
>

Why not? (Except that you actually must mean can not take its
representation as an input).

You can definitely do things like run a program that counts the number
of symbols in the input on a representation of itself, or if the program
is a compiler, run it on its own source code.

There is no limitation that prevents you from applying a Turing Machine
to a representation of itself.

In fact, as has been pointed out, there is no way for the Turing Mchine
to even know you have done this.

On Tuesday, 15 March 2022 at 04:04:06 UTC, André G. Isaak wrote:
> On 2022-03-14 21:07, olcott wrote:
> > On 3/14/2022 9:05 PM, André G. Isaak wrote:
> >> On 2022-03-14 20:02, olcott wrote:
> >>
> >> <snip nonresponsive post>
> >>
> >> Again, I'll repeat the question which you dishonestly snipped rather
> >> than answering. I won't bother putting it in all caps or repeating it
> >> five times.
> >>
> >> How does one encode Ĥ applied to ⟨Ĥ⟩ as a string which can be passed
> >> to Ĥ if that computation is in fact different from ⟨Ĥ⟩ ⟨Ĥ⟩?
> >>
> >
> > Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> >
> > The ⟨Ĥ⟩ ⟨Ĥ⟩ above is inherently exactly one level of indirect reference
> > away from Ĥ ⟨Ĥ⟩ above, thus making it utterly impossible to pass this
> > exact same Ĥ ⟨Ĥ⟩ as an input to embedded_H.
> There are no 'levels of indirection' when discussing Turing Machines.
>
> If there is no way to encode Ĥ ⟨Ĥ⟩ such that it can be given as an input
> to your decider, then your decider is broken since it must be able to
> provide an answer for *every* computation, including Ĥ ⟨Ĥ⟩.
>
Though that would actually be a genuine contribution to computer science.
If you could devise a language such that a large subset of halting and
non-halting machines could be described, but not machines for which the
halting status is difficult or impossible for a predefined halt decider to determine.

On 3/15/2022 6:35 AM, Malcolm McLean wrote:
> On Tuesday, 15 March 2022 at 04:04:06 UTC, André G. Isaak wrote:
>> On 2022-03-14 21:07, olcott wrote:
>>> On 3/14/2022 9:05 PM, André G. Isaak wrote:
>>>> On 2022-03-14 20:02, olcott wrote:
>>>>
>>>> <snip nonresponsive post>
>>>>
>>>> Again, I'll repeat the question which you dishonestly snipped rather
>>>> than answering. I won't bother putting it in all caps or repeating it
>>>> five times.
>>>>
>>>> How does one encode Ĥ applied to ⟨Ĥ⟩ as a string which can be passed
>>>> to Ĥ if that computation is in fact different from ⟨Ĥ⟩ ⟨Ĥ⟩?
>>>>
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> The ⟨Ĥ⟩ ⟨Ĥ⟩ above is inherently exactly one level of indirect reference
>>> away from Ĥ ⟨Ĥ⟩ above, thus making it utterly impossible to pass this
>>> exact same Ĥ ⟨Ĥ⟩ as an input to embedded_H.
>> There are no 'levels of indirection' when discussing Turing Machines.
>>
>> If there is no way to encode Ĥ ⟨Ĥ⟩ such that it can be given as an input
>> to your decider, then your decider is broken since it must be able to
>> provide an answer for *every* computation, including Ĥ ⟨Ĥ⟩.
>>
> Though that would actually be a genuine contribution to computer science.
> If you could devise a language such that a large subset of halting and
> non-halting machines could be described, but not machines for which the
> halting status is difficult or impossible for a predefined halt decider to determine.

André does not seem to be able to comprehend that a Turing machine
decider cannot possibly have its own self or an encoding of its own self
as its input. The closest thing possible that it can have is an encoding
of another different instance of itself.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
In the case above ⟨Ĥ⟩ ⟨Ĥ⟩ is exactly one level of indirect reference
away from Ĥ applied to ⟨Ĥ⟩. The copy of H embedded at Ĥ.qx is not
deciding the halt status of its own self (the exact same instance) it is
deciding the halt status of a different instance.

That neither André, Ben nor Richard can comprehend this does not
indicate that I am incorrect.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On Tuesday, 15 March 2022 at 14:51:44 UTC, olcott wrote:
> On 3/15/2022 6:35 AM, Malcolm McLean wrote:
> > On Tuesday, 15 March 2022 at 04:04:06 UTC, André G. Isaak wrote:
> >> On 2022-03-14 21:07, olcott wrote:
> >>> On 3/14/2022 9:05 PM, André G. Isaak wrote:
> >>>> On 2022-03-14 20:02, olcott wrote:
> >>>>
> >>>> <snip nonresponsive post>
> >>>>
> >>>> Again, I'll repeat the question which you dishonestly snipped rather
> >>>> than answering. I won't bother putting it in all caps or repeating it
> >>>> five times.
> >>>>
> >>>> How does one encode Ĥ applied to ⟨Ĥ⟩ as a string which can be passed
> >>>> to Ĥ if that computation is in fact different from ⟨Ĥ⟩ ⟨Ĥ⟩?
> >>>>
> >>>
> >>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> >>>
> >>> The ⟨Ĥ⟩ ⟨Ĥ⟩ above is inherently exactly one level of indirect reference
> >>> away from Ĥ ⟨Ĥ⟩ above, thus making it utterly impossible to pass this
> >>> exact same Ĥ ⟨Ĥ⟩ as an input to embedded_H.
> >> There are no 'levels of indirection' when discussing Turing Machines.
> >>
> >> If there is no way to encode Ĥ ⟨Ĥ⟩ such that it can be given as an input
> >> to your decider, then your decider is broken since it must be able to
> >> provide an answer for *every* computation, including Ĥ ⟨Ĥ⟩.
> >>
> > Though that would actually be a genuine contribution to computer science.
> > If you could devise a language such that a large subset of halting and
> > non-halting machines could be described, but not machines for which the
> > halting status is difficult or impossible for a predefined halt decider to determine.
> André does not seem to be able to comprehend that a Turing machine
> decider cannot possibly have its own self or an encoding of its own self
> as its input. The closest thing possible that it can have is an encoding
> of another different instance of itself.
>
So how would you describe a compiler which is "bootstrapped", i.e. fed its own
source code?

On 3/15/2022 10:44 AM, Malcolm McLean wrote:
> On Tuesday, 15 March 2022 at 14:51:44 UTC, olcott wrote:
>> On 3/15/2022 6:35 AM, Malcolm McLean wrote:
>>> On Tuesday, 15 March 2022 at 04:04:06 UTC, André G. Isaak wrote:
>>>> On 2022-03-14 21:07, olcott wrote:
>>>>> On 3/14/2022 9:05 PM, André G. Isaak wrote:
>>>>>> On 2022-03-14 20:02, olcott wrote:
>>>>>>
>>>>>> <snip nonresponsive post>
>>>>>>
>>>>>> Again, I'll repeat the question which you dishonestly snipped rather
>>>>>> than answering. I won't bother putting it in all caps or repeating it
>>>>>> five times.
>>>>>>
>>>>>> How does one encode Ĥ applied to ⟨Ĥ⟩ as a string which can be passed
>>>>>> to Ĥ if that computation is in fact different from ⟨Ĥ⟩ ⟨Ĥ⟩?
>>>>>>
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> The ⟨Ĥ⟩ ⟨Ĥ⟩ above is inherently exactly one level of indirect reference
>>>>> away from Ĥ ⟨Ĥ⟩ above, thus making it utterly impossible to pass this
>>>>> exact same Ĥ ⟨Ĥ⟩ as an input to embedded_H.
>>>> There are no 'levels of indirection' when discussing Turing Machines.
>>>>
>>>> If there is no way to encode Ĥ ⟨Ĥ⟩ such that it can be given as an input
>>>> to your decider, then your decider is broken since it must be able to
>>>> provide an answer for *every* computation, including Ĥ ⟨Ĥ⟩.
>>>>
>>> Though that would actually be a genuine contribution to computer science.
>>> If you could devise a language such that a large subset of halting and
>>> non-halting machines could be described, but not machines for which the
>>> halting status is difficult or impossible for a predefined halt decider to determine.
>> André does not seem to be able to comprehend that a Turing machine
>> decider cannot possibly have its own self or an encoding of its own self
>> as its input. The closest thing possible that it can have is an encoding
>> of another different instance of itself.
>>
> So how would you describe a compiler which is "bootstrapped", i.e. fed its own
> source code?

A compiler that is fed its own source-code is not the same because the
compiler does not execute this source-code.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 3/15/2022 10:11 AM, olcott wrote:
> On 3/15/2022 10:44 AM, Malcolm McLean wrote:

<MAJOR SNIP>

>> So how would you describe a compiler which is "bootstrapped", i.e. fed
>> its own
>> source code?
>
> A compiler that is fed its own source-code is not the same because the
> compiler does not execute this source-code.
This is one of your best Peter. Along the way you've had 100s of
messages that have said that simulation as a basis for a Halting Problem
solution is hopeless. Of course you pay no attention because it's
unlikely you understood what you were being told. So here you are
looping back over years of the same bone headed approach.

Let's start with a few basics:

Nothing executes source code; even an interpreter ingests it first.

All an ingestor, compiler, or assembler does is to change a program
languages representation into another equivalent form. If it's working
properly, that is.

So the properly compiled compiler is just another representation of its
source code. And, indeed, that brings us to the conclusion of this
little explanation:

THE COMPILER IN ONE REPRESENTATION IS PROCESSING ITSELF IN ANOTHER
REPRESENTATION. SO YOU ARE WRONG ONCE AGAIN (AS ALWAYS).

Before leaving you to your hard won state as a total proud ignoramus,
I'll list these terms in the above that you don't understand:

simulation, Halting Problem, source code, interpreter, ingest, compiler,
assembler, equivalent form, representation, ignoramus.

Quite a list isn't it? Start with "ignoramus" if you want that to go
away, look it up. Then go through the other words one at a time. Ben has
offered, many many times, to teach you if you ask. Why not? Your legacy
and impression on the world has turned from proud ignorance to
stupidity. The former is curable, the latter is not. Get busy and leave
a good impression!
--
Jeff Barnett

On 3/15/2022 1:58 PM, Jeff Barnett wrote:
> On 3/15/2022 10:11 AM, olcott wrote:
>> On 3/15/2022 10:44 AM, Malcolm McLean wrote:
>
>    <MAJOR SNIP>
>
>>> So how would you describe a compiler which is "bootstrapped", i.e.
>>> fed its own
>>> source code?
>>
>> A compiler that is fed its own source-code is not the same because the
>> compiler does not execute this source-code.
> This is one of your best Peter. Along the way you've had 100s of
> messages that have said that simulation as a basis for a Halting Problem
> solution is hopeless. Of course you pay no attention because it's
> unlikely you understood what you were being told. So here you are
> looping back over years of the same bone headed approach.
>
> Let's start with a few basics:
>
> Nothing executes source code; even an interpreter ingests it first.
>

A compiler the compiles its own source-code is nothing at all like
executing this source code.

An interpreter that interprets source code can be reasonably construed
as running this source code.

When a BASIC programmer says that they ran their program they do not
provide all of the tedious details of the technical intermediate steps.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 2022-03-15 08:51, olcott wrote:
> On 3/15/2022 6:35 AM, Malcolm McLean wrote:
>> On Tuesday, 15 March 2022 at 04:04:06 UTC, André G. Isaak wrote:
>>> On 2022-03-14 21:07, olcott wrote:
>>>> On 3/14/2022 9:05 PM, André G. Isaak wrote:
>>>>> On 2022-03-14 20:02, olcott wrote:
>>>>>
>>>>> <snip nonresponsive post>
>>>>>
>>>>> Again, I'll repeat the question which you dishonestly snipped rather
>>>>> than answering. I won't bother putting it in all caps or repeating it
>>>>> five times.
>>>>>
>>>>> How does one encode Ĥ applied to ⟨Ĥ⟩ as a string which can be passed
>>>>> to Ĥ if that computation is in fact different from ⟨Ĥ⟩ ⟨Ĥ⟩?
>>>>>
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> The ⟨Ĥ⟩ ⟨Ĥ⟩ above is inherently exactly one level of indirect reference
>>>> away from Ĥ ⟨Ĥ⟩ above, thus making it utterly impossible to pass this
>>>> exact same Ĥ ⟨Ĥ⟩ as an input to embedded_H.
>>> There are no 'levels of indirection' when discussing Turing Machines.
>>>
>>> If there is no way to encode Ĥ ⟨Ĥ⟩ such that it can be given as an input
>>> to your decider, then your decider is broken since it must be able to
>>> provide an answer for *every* computation, including Ĥ ⟨Ĥ⟩.
>>>
>> Though that would actually be a genuine contribution to computer science.
>> If you could devise a language such that a large subset of halting and
>> non-halting machines could be described, but not machines for which the
>> halting status is difficult or impossible for a predefined halt
>> decider to determine.
>
> André does not seem to be able to comprehend that a Turing machine
> decider cannot possibly have its own self or an encoding of its own self
> as its input. The closest thing possible that it can have is an encoding
> of another different instance of itself.

Computations don't have different instances. What would it even mean to
'instantiate' a computation?

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

On 3/15/2022 3:24 PM, André G. Isaak wrote:
> On 2022-03-15 08:51, olcott wrote:
>> On 3/15/2022 6:35 AM, Malcolm McLean wrote:
>>> On Tuesday, 15 March 2022 at 04:04:06 UTC, André G. Isaak wrote:
>>>> On 2022-03-14 21:07, olcott wrote:
>>>>> On 3/14/2022 9:05 PM, André G. Isaak wrote:
>>>>>> On 2022-03-14 20:02, olcott wrote:
>>>>>>
>>>>>> <snip nonresponsive post>
>>>>>>
>>>>>> Again, I'll repeat the question which you dishonestly snipped rather
>>>>>> than answering. I won't bother putting it in all caps or repeating it
>>>>>> five times.
>>>>>>
>>>>>> How does one encode Ĥ applied to ⟨Ĥ⟩ as a string which can be passed
>>>>>> to Ĥ if that computation is in fact different from ⟨Ĥ⟩ ⟨Ĥ⟩?
>>>>>>
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> The ⟨Ĥ⟩ ⟨Ĥ⟩ above is inherently exactly one level of indirect
>>>>> reference
>>>>> away from Ĥ ⟨Ĥ⟩ above, thus making it utterly impossible to pass this
>>>>> exact same Ĥ ⟨Ĥ⟩ as an input to embedded_H.
>>>> There are no 'levels of indirection' when discussing Turing Machines.
>>>>
>>>> If there is no way to encode Ĥ ⟨Ĥ⟩ such that it can be given as an
>>>> input
>>>> to your decider, then your decider is broken since it must be able to
>>>> provide an answer for *every* computation, including Ĥ ⟨Ĥ⟩.
>>>>
>>> Though that would actually be a genuine contribution to computer
>>> science.
>>> If you could devise a language such that a large subset of halting and
>>> non-halting machines could be described, but not machines for which the
>>> halting status is difficult or impossible for a predefined halt
>>> decider to determine.
>>
>> André does not seem to be able to comprehend that a Turing machine
>> decider cannot possibly have its own self or an encoding of its own
>> self as its input. The closest thing possible that it can have is an
>> encoding of another different instance of itself.
>
> Computations don't have different instances. What would it even mean to
> 'instantiate' a computation?
>
> André
>

A Turing machine UTM that is simulating its own Turing machine
description is two distinct instances: (executed and simulated) even if
computer science does not bother to pay attention to this level of
detail, or have the terminology to express it.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 3/15/2022 1:44 PM, olcott wrote:
> On 3/15/2022 1:58 PM, Jeff Barnett wrote:
>> On 3/15/2022 10:11 AM, olcott wrote:
>>> On 3/15/2022 10:44 AM, Malcolm McLean wrote:
>>
>>     <MAJOR SNIP>
>>
>>>> So how would you describe a compiler which is "bootstrapped", i.e.
>>>> fed its own
>>>> source code?
>>>
>>> A compiler that is fed its own source-code is not the same because
>>> the compiler does not execute this source-code.
>> This is one of your best Peter. Along the way you've had 100s of
>> messages that have said that simulation as a basis for a Halting
>> Problem solution is hopeless. Of course you pay no attention because
>> it's unlikely you understood what you were being told. So here you are
>> looping back over years of the same bone headed approach.
>>
>> Let's start with a few basics:
>>
>> Nothing executes source code; even an interpreter ingests it first.
>>
>
> A compiler the compiles its own source-code is nothing at all like
> executing this source code.
You really do have rocks in your head. Think for at least 2 seconds
before responding and getting it all wrong. The mistakes you are making
with the above statement are so basic that I hardly know where to start.
As I've been told many times it's harder to teach Kindergarten than grad
students. And in this instance, with you, we have a sixty year old
crawling around in diapers.
> An interpreter that interprets source code can be reasonably construed
> as running this source code.
Perhaps. The issue is it really doesn't know that it is it's own source
code, does it? And, in fact, neither it nor any observer is aware of any
vicious self reference. Only a dunce would worry about it. You do worry
don't you?
> When a BASIC programmer says that they ran their program they do not
> provide all of the tedious details of the technical intermediate steps.
Certainly not when they run it. But tedious details are often the right
information when they want to describe it or prove something about or
debug it, etc.
And then there's you! You fowled (Like the spelling? Think bird shit.)
up again by slicing important and helpful text from the message you are
replying to. Was it because it wasn't relevant? No! It was because you
dimly perceived that your mindless response was already addressed. Why
advertise that you are a freaking idiot who does not read much and can
not read for comprehension?
Take the advice given in the part you chopped off: ask Ben for help to
understand basic vocabulary and concepts then go from there?

In case anyone cares, the original message that PO replied to, while
soiling his pants, follows:
---------------------------------------------------------------------
On 3/15/2022 10:11 AM, olcott wrote:
> On 3/15/2022 10:44 AM, Malcolm McLean wrote:
<MAJOR SNIP>
>> So how would you describe a compiler which is "bootstrapped", i.e.
fed its own
>> source code?
>
> A compiler that is fed its own source-code is not the same because
the compiler does not execute this source-code.
This is one of your best Peter. Along the way you've had 100s of
messages that have said that simulation as a basis for a Halting Problem
solution is hopeless. Of course you pay no attention because it's
unlikely you understood what you were being told. So here you are
looping back over years of the same bone headed approach.
Let's start with a few basics:
Nothing executes source code; even an interpreter ingests it first.
All an ingestor, compiler, or assembler does is to change a program
languages representation into another equivalent form. If it's working
properly, that is.
So the properly compiled compiler is just another representation of its
source code. And, indeed, that brings us to the conclusion of this
little explanation:
THE COMPILER IN ONE REPRESENTATION IS PROCESSING ITSELF IN ANOTHER
REPRESENTATION. SO YOU ARE WRONG ONCE AGAIN (AS ALWAYS).
Before leaving you to your hard won state as a total proud ignoramus,
I'll list these terms in the above that you don't understand:
simulation, Halting Problem, source code, interpreter, ingest, compiler,
assembler, equivalent form, representation, ignoramus.
Quite a list isn't it? Start with "ignoramus" if you want that to go
away, look it up. Then go through the other words one at a time. Ben has
offered, many many times, to teach you if you ask. Why not? Your legacy
and impression on the world has turned from proud ignorance to
stupidity. The former is curable, the latter is not. Get busy and leave
a good impression!
--
Jeff Barnett

On 3/15/2022 4:48 PM, Jeff Barnett wrote:
> On 3/15/2022 1:44 PM, olcott wrote:
>> On 3/15/2022 1:58 PM, Jeff Barnett wrote:
>>> On 3/15/2022 10:11 AM, olcott wrote:
>>>> On 3/15/2022 10:44 AM, Malcolm McLean wrote:
>>>
>>>     <MAJOR SNIP>
>>>
>>>>> So how would you describe a compiler which is "bootstrapped", i.e.
>>>>> fed its own
>>>>> source code?
>>>>
>>>> A compiler that is fed its own source-code is not the same because
>>>> the compiler does not execute this source-code.
>>> This is one of your best Peter. Along the way you've had 100s of
>>> messages that have said that simulation as a basis for a Halting
>>> Problem solution is hopeless. Of course you pay no attention because
>>> it's unlikely you understood what you were being told. So here you
>>> are looping back over years of the same bone headed approach.
>>>
>>> Let's start with a few basics:
>>>
>>> Nothing executes source code; even an interpreter ingests it first.
>>>
>>
>> A compiler the compiles its own source-code is nothing at all like
>> executing this source code.
>
> You really do have rocks in your head. Think for at least 2 seconds
> before responding and getting it all wrong. The mistakes you are making
> with the above statement are so basic that I hardly know where to start.
> As I've been told many times it's harder to teach Kindergarten than grad
> students. And in this instance, with you, we have a sixty year old
> crawling around in diapers.
>
>> An interpreter that interprets source code can be reasonably construed
>> as running this source code.
>
> Perhaps. The issue is it really doesn't know that it is it's own source
> code, does it? And, in fact, neither it nor any observer is aware of any
> vicious self reference. Only a dunce would worry about it. You do worry
> don't you?

In other words you are saying that no one is bright enough to be able to
detect what is essentially infinite recursion.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 3/15/2022 3:24 PM, André G. Isaak wrote:
> On 2022-03-15 08:51, olcott wrote:
>> On 3/15/2022 6:35 AM, Malcolm McLean wrote:
>>> On Tuesday, 15 March 2022 at 04:04:06 UTC, André G. Isaak wrote:
>>>> On 2022-03-14 21:07, olcott wrote:
>>>>> On 3/14/2022 9:05 PM, André G. Isaak wrote:
>>>>>> On 2022-03-14 20:02, olcott wrote:
>>>>>>
>>>>>> <snip nonresponsive post>
>>>>>>
>>>>>> Again, I'll repeat the question which you dishonestly snipped rather
>>>>>> than answering. I won't bother putting it in all caps or repeating it
>>>>>> five times.
>>>>>>
>>>>>> How does one encode Ĥ applied to ⟨Ĥ⟩ as a string which can be passed
>>>>>> to Ĥ if that computation is in fact different from ⟨Ĥ⟩ ⟨Ĥ⟩?
>>>>>>
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> The ⟨Ĥ⟩ ⟨Ĥ⟩ above is inherently exactly one level of indirect
>>>>> reference
>>>>> away from Ĥ ⟨Ĥ⟩ above, thus making it utterly impossible to pass this
>>>>> exact same Ĥ ⟨Ĥ⟩ as an input to embedded_H.
>>>> There are no 'levels of indirection' when discussing Turing Machines.
>>>>
>>>> If there is no way to encode Ĥ ⟨Ĥ⟩ such that it can be given as an
>>>> input
>>>> to your decider, then your decider is broken since it must be able to
>>>> provide an answer for *every* computation, including Ĥ ⟨Ĥ⟩.
>>>>
>>> Though that would actually be a genuine contribution to computer
>>> science.
>>> If you could devise a language such that a large subset of halting and
>>> non-halting machines could be described, but not machines for which the
>>> halting status is difficult or impossible for a predefined halt
>>> decider to determine.
>>
>> André does not seem to be able to comprehend that a Turing machine
>> decider cannot possibly have its own self or an encoding of its own
>> self as its input. The closest thing possible that it can have is an
>> encoding of another different instance of itself.
>
> Computations don't have different instances. What would it even mean to
> 'instantiate' a computation?
>
> André
>

Back to the key point:

That ⟨Ĥ⟩ ⟨Ĥ⟩ finite strings specify non-halting behavior when correctly
simulated by the UTM within embedded_H is the same as these finite
strings specifying non-halting behavior when correctly interpreted by a
BASIC in interpreter.

10 PRINT "Hello, World!"
20 goto 10
30 END

When Ĥ is applied to ⟨Ĥ⟩
Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩

Then these steps would keep repeating:
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...

The above repeating pattern shows that the correctly simulated input to
embedded_H would never reach its final state of ⟨Ĥ⟩.qn conclusively
proving that this simulated input never halts. This enables embedded_H
to abort its simulation and correctly transition to Ĥ.qn.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 3/15/22 9:15 PM, olcott wrote:
> On 3/15/2022 3:24 PM, André G. Isaak wrote:
>> On 2022-03-15 08:51, olcott wrote:
>>> On 3/15/2022 6:35 AM, Malcolm McLean wrote:
>>>> On Tuesday, 15 March 2022 at 04:04:06 UTC, André G. Isaak wrote:
>>>>> On 2022-03-14 21:07, olcott wrote:
>>>>>> On 3/14/2022 9:05 PM, André G. Isaak wrote:
>>>>>>> On 2022-03-14 20:02, olcott wrote:
>>>>>>>
>>>>>>> <snip nonresponsive post>
>>>>>>>
>>>>>>> Again, I'll repeat the question which you dishonestly snipped rather
>>>>>>> than answering. I won't bother putting it in all caps or
>>>>>>> repeating it
>>>>>>> five times.
>>>>>>>
>>>>>>> How does one encode Ĥ applied to ⟨Ĥ⟩ as a string which can be passed
>>>>>>> to Ĥ if that computation is in fact different from ⟨Ĥ⟩ ⟨Ĥ⟩?
>>>>>>>
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> The ⟨Ĥ⟩ ⟨Ĥ⟩ above is inherently exactly one level of indirect
>>>>>> reference
>>>>>> away from Ĥ ⟨Ĥ⟩ above, thus making it utterly impossible to pass this
>>>>>> exact same Ĥ ⟨Ĥ⟩ as an input to embedded_H.
>>>>> There are no 'levels of indirection' when discussing Turing Machines.
>>>>>
>>>>> If there is no way to encode Ĥ ⟨Ĥ⟩ such that it can be given as an
>>>>> input
>>>>> to your decider, then your decider is broken since it must be able to
>>>>> provide an answer for *every* computation, including Ĥ ⟨Ĥ⟩.
>>>>>
>>>> Though that would actually be a genuine contribution to computer
>>>> science.
>>>> If you could devise a language such that a large subset of halting and
>>>> non-halting machines could be described, but not machines for which the
>>>> halting status is difficult or impossible for a predefined halt
>>>> decider to determine.
>>>
>>> André does not seem to be able to comprehend that a Turing machine
>>> decider cannot possibly have its own self or an encoding of its own
>>> self as its input. The closest thing possible that it can have is an
>>> encoding of another different instance of itself.
>>
>> Computations don't have different instances. What would it even mean
>> to 'instantiate' a computation?
>>
>> André
>>
>
> Back to the key point:
>
> That ⟨Ĥ⟩ ⟨Ĥ⟩ finite strings specify non-halting behavior when correctly
> simulated by the UTM within embedded_H is the same as these finite
> strings specifying non-halting behavior when correctly interpreted by a
> BASIC in interpreter.
>
> 10 PRINT "Hello, World!"
> 20 goto 10
> 30 END
>
> When Ĥ is applied to ⟨Ĥ⟩
>   Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>
> Then these steps would keep repeating:
>   Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>   Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>   Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>
> The above repeating pattern shows that the correctly simulated input to
> embedded_H would never reach its final state of ⟨Ĥ⟩.qn conclusively
> proving that this simulated input never halts. This enables embedded_H
> to abort its simulation and correctly transition to Ĥ.qn.
>
>

But that infinite behavor only occurs if the embedded_H NEVER aborts its
simulation and thus it fails at the requirement to GIVE the answer.

If ANY of the embedded_Hs abort their simulation (and thus ALL MUST)
then it will return to its 'calling' H^ and that H^ will Halt, and the
'infinite loop' collapses.

THus either you err in saying that you H actually gave the answer, or
that it correctly simulated the resuts.

The later has the problem that if embeedded_H does abort its simulation,
then it wasn't a UTM in the first place, so its behavior of not reaching
the final state doesn't define non-halting.

FAIL.

On 3/15/22 5:44 PM, olcott wrote:
> On 3/15/2022 3:24 PM, André G. Isaak wrote:
>> On 2022-03-15 08:51, olcott wrote:
>>> On 3/15/2022 6:35 AM, Malcolm McLean wrote:
>>>> On Tuesday, 15 March 2022 at 04:04:06 UTC, André G. Isaak wrote:
>>>>> On 2022-03-14 21:07, olcott wrote:
>>>>>> On 3/14/2022 9:05 PM, André G. Isaak wrote:
>>>>>>> On 2022-03-14 20:02, olcott wrote:
>>>>>>>
>>>>>>> <snip nonresponsive post>
>>>>>>>
>>>>>>> Again, I'll repeat the question which you dishonestly snipped rather
>>>>>>> than answering. I won't bother putting it in all caps or
>>>>>>> repeating it
>>>>>>> five times.
>>>>>>>
>>>>>>> How does one encode Ĥ applied to ⟨Ĥ⟩ as a string which can be passed
>>>>>>> to Ĥ if that computation is in fact different from ⟨Ĥ⟩ ⟨Ĥ⟩?
>>>>>>>
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> The ⟨Ĥ⟩ ⟨Ĥ⟩ above is inherently exactly one level of indirect
>>>>>> reference
>>>>>> away from Ĥ ⟨Ĥ⟩ above, thus making it utterly impossible to pass this
>>>>>> exact same Ĥ ⟨Ĥ⟩ as an input to embedded_H.
>>>>> There are no 'levels of indirection' when discussing Turing Machines.
>>>>>
>>>>> If there is no way to encode Ĥ ⟨Ĥ⟩ such that it can be given as an
>>>>> input
>>>>> to your decider, then your decider is broken since it must be able to
>>>>> provide an answer for *every* computation, including Ĥ ⟨Ĥ⟩.
>>>>>
>>>> Though that would actually be a genuine contribution to computer
>>>> science.
>>>> If you could devise a language such that a large subset of halting and
>>>> non-halting machines could be described, but not machines for which the
>>>> halting status is difficult or impossible for a predefined halt
>>>> decider to determine.
>>>
>>> André does not seem to be able to comprehend that a Turing machine
>>> decider cannot possibly have its own self or an encoding of its own
>>> self as its input. The closest thing possible that it can have is an
>>> encoding of another different instance of itself.
>>
>> Computations don't have different instances. What would it even mean
>> to 'instantiate' a computation?
>>
>> André
>>
>
> A Turing machine UTM that is simulating its own Turing machine
> description is two distinct instances: (executed and simulated) even if
> computer science does not bother to pay attention to this level of
> detail, or have the terminology to express it.
>

Right, but as has been shown, if H actually IS a UTM, then BY DEFINITION
it NEVER aborts its simulation, and thus can't be a Halting Decider. It
can be a Halting Recognizer, but that isn't good enough for the problem.

Once you modify the algorithm to abort if it thinks the simulation will
be non-halting it no longer becomes an actual source of Truth for the
behavior.

Yes, there are many machine it can correctly detect an infinite behavior
pattern and correctly decide that those input are non-halting, but as I
have previous shown, there is no finite pattern in the simulation of
<H^> <H^> that the H that was used to build that H^ can use to detect
the non-halting behavior. ANY pattern that H tries to use, makes that H^
applied to <H^> Halting.

On 3/15/22 6:02 PM, olcott wrote:
> On 3/15/2022 4:48 PM, Jeff Barnett wrote:
>> On 3/15/2022 1:44 PM, olcott wrote:
>>> On 3/15/2022 1:58 PM, Jeff Barnett wrote:
>>>> On 3/15/2022 10:11 AM, olcott wrote:
>>>>> On 3/15/2022 10:44 AM, Malcolm McLean wrote:
>>>>
>>>>     <MAJOR SNIP>
>>>>
>>>>>> So how would you describe a compiler which is "bootstrapped", i.e.
>>>>>> fed its own
>>>>>> source code?
>>>>>
>>>>> A compiler that is fed its own source-code is not the same because
>>>>> the compiler does not execute this source-code.
>>>> This is one of your best Peter. Along the way you've had 100s of
>>>> messages that have said that simulation as a basis for a Halting
>>>> Problem solution is hopeless. Of course you pay no attention because
>>>> it's unlikely you understood what you were being told. So here you
>>>> are looping back over years of the same bone headed approach.
>>>>
>>>> Let's start with a few basics:
>>>>
>>>> Nothing executes source code; even an interpreter ingests it first.
>>>>
>>>
>>> A compiler the compiles its own source-code is nothing at all like
>>> executing this source code.
>>
>> You really do have rocks in your head. Think for at least 2 seconds
>> before responding and getting it all wrong. The mistakes you are
>> making with the above statement are so basic that I hardly know where
>> to start. As I've been told many times it's harder to teach
>> Kindergarten than grad students. And in this instance, with you, we
>> have a sixty year old crawling around in diapers.
>>
>>> An interpreter that interprets source code can be reasonably
>>> construed as running this source code.
>>
>> Perhaps. The issue is it really doesn't know that it is it's own
>> source code, does it? And, in fact, neither it nor any observer is
>> aware of any vicious self reference. Only a dunce would worry about
>> it. You do worry don't you?
>
> In other words you are saying that no one is bright enough to be able to
> detect what is essentially infinite recursion.
>

The problem is the recursion isn't infinite if H detects it and aborts
its simulation an goes to H.Qn.

This is the effect of that contradictory self-reference, which is
ALLOWED by the form of the field.