On 2023-04-08 14:10, Ben Bacarisse wrote:
> Richard Damon <Richard@Damon-Family.org> writes:
>
>> On 4/7/23 8:37 PM, olcott wrote:
>
>>> A masters degree in EE is probably not nearly as much CS as a BSBS in CS.
>>
>> You think so? Rmmember, my Masters was in Electrical Engineering and
>> Computer Science, so I did get a lot of CS material too.
>
> Is PO saying he has a double BS degree? You couldn't make it up!

I think he means BS in Bullshit.

André

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

On 4/8/2023 3:22 PM, André G. Isaak wrote:
> On 2023-04-08 14:10, Ben Bacarisse wrote:
>> Richard Damon <Richard@Damon-Family.org> writes:
>>
>>> On 4/7/23 8:37 PM, olcott wrote:
>>
>>>> A masters degree in EE is probably not nearly as much CS as a BSBS
>>>> in CS.
>>>
>>> You think so? Rmmember, my Masters was in Electrical Engineering and
>>> Computer Science, so I did get a lot of CS material too.
>>
>> Is PO saying he has a double BS degree?  You couldn't make it up!
>
> I think he means BS in Bullshit.
>
> André
>

01 int D(int (*x)())
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }

Every halt decider must report on the actual behavior of its actual
input. The notion of a UTM establishes that H is correct to base its
halt status decision on a finite number of steps of D correctly
simulated by H.

computation that halts… “the Turing machine will halt whenever it enters
a final state” (Linz:1990:234)

Everyone with technical competence equivalent to that of a BSCS grad can
see that every D correctly simulated by any H cannot possibly reach its
own simulated final state and halt.

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

On 4/8/23 4:43 PM, olcott wrote:
> On 4/8/2023 3:22 PM, André G. Isaak wrote:
>> On 2023-04-08 14:10, Ben Bacarisse wrote:
>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>
>>>> On 4/7/23 8:37 PM, olcott wrote:
>>>
>>>>> A masters degree in EE is probably not nearly as much CS as a BSBS
>>>>> in CS.
>>>>
>>>> You think so? Rmmember, my Masters was in Electrical Engineering and
>>>> Computer Science, so I did get a lot of CS material too.
>>>
>>> Is PO saying he has a double BS degree?  You couldn't make it up!
>>
>> I think he means BS in Bullshit.
>>
>> André
>>
>
> 01 int D(int (*x)())
> 02 {
> 03  int Halt_Status = H(x, x);
> 04  if (Halt_Status)
> 05    HERE: goto HERE;
> 06  return Halt_Status;
> 07 }
> 08
> 09 void main()
> 10 {
> 11  H(D,D);
> 12 }
>
> Every halt decider must report on the actual behavior of its actual
> input.

Right, H(D,D) must report on the actual behavior of its actual input,
that is D(D), or UTM(D,D), both of which halt since H(D,D) returns 0.

> The notion of a UTM establishes that H is correct to base its
> halt status decision on a finite number of steps of D correctly
> simulated by H.

NO. Just shows you don't understand what a UTM is.

>
> computation that halts… “the Turing machine will halt whenever it enters
> a final state” (Linz:1990:234)

Right, THE TURING MACHINE, that is the direct exectution of D(D) which
Halts.

>
> Everyone with technical competence equivalent to that of a BSCS grad can
> see that every D correctly simulated by any H cannot possibly reach its
> own simulated final state and halt.
>
>

Except we aren't concerned about "its own simulated final state", we are
concerned about the ACTUAL TURING MACHINE, which halts, or the UTM
simulation of the input, which Halts, so the correct answer is IT HALTS.

The fact that there exists no H that can return an answer and also
correctly simulatd its input per the definitions of a UTM just shows tha
the problem is impossible to solve by this method.

Your failure to see this shows that you do NOT have the technical
competence that would be expected out of someone with a proper BSCS
degree, or even a just a smattering of understand of the problem. This
problem is normally well understood by 1st year students, so it shows
how good your education is.

But then, you ARE a person that thinks its ok for you to possess child
porn because you are "God".

On 4/8/2023 3:43 PM, olcott wrote:
> On 4/8/2023 3:22 PM, André G. Isaak wrote:
>> On 2023-04-08 14:10, Ben Bacarisse wrote:
>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>
>>>> On 4/7/23 8:37 PM, olcott wrote:
>>>
>>>>> A masters degree in EE is probably not nearly as much CS as a BSBS
>>>>> in CS.
>>>>
>>>> You think so? Rmmember, my Masters was in Electrical Engineering and
>>>> Computer Science, so I did get a lot of CS material too.
>>>
>>> Is PO saying he has a double BS degree?  You couldn't make it up!
>>
>> I think he means BS in Bullshit.
>>
>> André
>>
>
> 01 int D(int (*x)())
> 02 {
> 03  int Halt_Status = H(x, x);
> 04  if (Halt_Status)
> 05    HERE: goto HERE;
> 06  return Halt_Status;
> 07 }
> 08
> 09 void main()
> 10 {
> 11  H(D,D);
> 12 }
>
> Every halt decider must report on the actual behavior of its actual
> input. The notion of a UTM establishes that H is correct to base its
> halt status decision on a finite number of steps of D correctly
> simulated by H.
>

The notion of a UTM guarantees that when N steps of D are correctly
simulated by H that this <is> the actual behavior that D specifies to H.

> computation that halts… “the Turing machine will halt whenever it enters
> a final state” (Linz:1990:234)
>
> Everyone with technical competence equivalent to that of a BSCS grad can
> see that every D correctly simulated by any H cannot possibly reach its
> own simulated final state and halt.
>
>

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

On 4/8/23 5:14 PM, olcott wrote:

>
> The notion of a UTM guarantees that when N steps of D are correctly
> simulated by H that this <is> the actual behavior that D specifies to H.
>

But N steps of behavior don't tell you if the machine will actually Halt.

The only behavior that matters, is the FINAL behavior of the machine.

Note, H needs to decide what THIS D does, which is using a SPECIFIC H
that just happens to be the H that gives the claimed right answer.

It doesn't get to answer about "some other D" build on "some other H",
but only the D given to it based on the H that is claimed to give the
right answer, and that is the one that ultimately decides to abort its
simulation and return 0.

YOU JUST LIE about what you are doing.

On 4/8/2023 4:14 PM, olcott wrote:
> On 4/8/2023 3:43 PM, olcott wrote:
>> On 4/8/2023 3:22 PM, André G. Isaak wrote:
>>> On 2023-04-08 14:10, Ben Bacarisse wrote:
>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>
>>>>> On 4/7/23 8:37 PM, olcott wrote:
>>>>
>>>>>> A masters degree in EE is probably not nearly as much CS as a BSBS
>>>>>> in CS.
>>>>>
>>>>> You think so? Rmmember, my Masters was in Electrical Engineering and
>>>>> Computer Science, so I did get a lot of CS material too.
>>>>
>>>> Is PO saying he has a double BS degree?  You couldn't make it up!
>>>
>>> I think he means BS in Bullshit.
>>>
>>> André
>>>
>>
>> 01 int D(int (*x)())
>> 02 {
>> 03  int Halt_Status = H(x, x);
>> 04  if (Halt_Status)
>> 05    HERE: goto HERE;
>> 06  return Halt_Status;
>> 07 }
>> 08
>> 09 void main()
>> 10 {
>> 11  H(D,D);
>> 12 }
>>
>> Every halt decider must report on the actual behavior of its actual
>> input. The notion of a UTM establishes that H is correct to base its
>> halt status decision on a finite number of steps of D correctly
>> simulated by H.
>>
>
> The notion of a UTM guarantees that when N steps of D are correctly
> simulated by H that this <is> the actual behavior that D specifies to H.
>
>

But N steps of behavior don't tell you if the machine will actually Halt.

When halting requires reaching a simulated final state then N steps of
simulation does conclusively prove that D simulated by H never halts.

>
>
>> computation that halts… “the Turing machine will halt whenever it
>> enters a final state” (Linz:1990:234)
>>
>> Everyone with technical competence equivalent to that of a BSCS grad can
>> see that every D correctly simulated by any H cannot possibly reach its
>> own simulated final state and halt.
>>
>>
>

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

On 2023-04-08 15:14, olcott wrote:
> On 4/8/2023 3:43 PM, olcott wrote:
>> On 4/8/2023 3:22 PM, André G. Isaak wrote:
>>> On 2023-04-08 14:10, Ben Bacarisse wrote:
>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>
>>>>> On 4/7/23 8:37 PM, olcott wrote:
>>>>
>>>>>> A masters degree in EE is probably not nearly as much CS as a BSBS
>>>>>> in CS.
>>>>>
>>>>> You think so? Rmmember, my Masters was in Electrical Engineering and
>>>>> Computer Science, so I did get a lot of CS material too.
>>>>
>>>> Is PO saying he has a double BS degree?  You couldn't make it up!
>>>
>>> I think he means BS in Bullshit.
>>>
>>> André
>>>
>>
>> 01 int D(int (*x)())
>> 02 {
>> 03  int Halt_Status = H(x, x);
>> 04  if (Halt_Status)
>> 05    HERE: goto HERE;
>> 06  return Halt_Status;
>> 07 }
>> 08
>> 09 void main()
>> 10 {
>> 11  H(D,D);
>> 12 }
>>
>> Every halt decider must report on the actual behavior of its actual
>> input. The notion of a UTM establishes that H is correct to base its
>> halt status decision on a finite number of steps of D correctly
>> simulated by H.
>>
>
> The notion of a UTM guarantees that when N steps of D are correctly
> simulated by H that this <is> the actual behavior that D specifies to H.

The notion of a UTM is entirely irrelevant since your H and D aren't
formulated in terms of Turing Machines in the first place. No where does
your code involve a TM, let alone a UTM.

The notion of a UTM is simply that it is possible to construct a single
TM which can mimic the behaviour of all other TMs. It says nothing
whatsoever about making *decisions* about the properties of those TMs.

André

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

On 4/8/23 5:27 PM, olcott wrote:
>
> But N steps of behavior don't tell you if the machine will actually Halt.
>
> When halting requires reaching a simulated final state then N steps of
> simulation does conclusively prove that D simulated by H never halts.

Except it doesn't require reaching a simulated final state, it requires
that actual machine to reach the final state, or a UTM simulation to
reach a final state, an aborted simulation not reaching a final state
doesn't prove anything,

You are just stuck with your strawman fallacy showing that you are just
as smart as a man with a straw brain.

And acting like a three-year-old just proves your (lack of) intelegence.

Maybe that is why you think it is ok for you to have Child Porn, you
think it is just pictures of people your own age (or your elders).

Richard Damon <Richard@Damon-Family.org> writes:

> On 4/8/23 4:10 PM, Ben Bacarisse wrote:
>> Richard Damon <Richard@Damon-Family.org> writes:
>>
>>> On 4/7/23 8:37 PM, olcott wrote:
>>
>>>> A masters degree in EE is probably not nearly as much CS as a BSBS in CS.
>>>
>>> You think so? Rmmember, my Masters was in Electrical Engineering and
>>> Computer Science, so I did get a lot of CS material too.
>> Is PO saying he has a double BS degree? You couldn't make it up!
>>
>
> No, I think he is says he has a Bachelors of Science of Bull Shit Computer
> Science.

I think the joke got lost. In the UK, BS means bullshit. It never
means Bachelors of Science so I was pretending he's claiming to have a
bullshit degree in bullshit. (I know what his BSBS degree really is --
it was just too perfect an opportunity.)

--
Ben.

On 4/8/2023 4:39 PM, André G. Isaak wrote:
> On 2023-04-08 15:14, olcott wrote:
>> On 4/8/2023 3:43 PM, olcott wrote:
>>> On 4/8/2023 3:22 PM, André G. Isaak wrote:
>>>> On 2023-04-08 14:10, Ben Bacarisse wrote:
>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>
>>>>>> On 4/7/23 8:37 PM, olcott wrote:
>>>>>
>>>>>>> A masters degree in EE is probably not nearly as much CS as a
>>>>>>> BSBS in CS.
>>>>>>
>>>>>> You think so? Rmmember, my Masters was in Electrical Engineering and
>>>>>> Computer Science, so I did get a lot of CS material too.
>>>>>
>>>>> Is PO saying he has a double BS degree?  You couldn't make it up!
>>>>
>>>> I think he means BS in Bullshit.
>>>>
>>>> André
>>>>
>>>
>>> 01 int D(int (*x)())
>>> 02 {
>>> 03  int Halt_Status = H(x, x);
>>> 04  if (Halt_Status)
>>> 05    HERE: goto HERE;
>>> 06  return Halt_Status;
>>> 07 }
>>> 08
>>> 09 void main()
>>> 10 {
>>> 11  H(D,D);
>>> 12 }
>>>
>>> Every halt decider must report on the actual behavior of its actual
>>> input. The notion of a UTM establishes that H is correct to base its
>>> halt status decision on a finite number of steps of D correctly
>>> simulated by H.
>>>
>>
>> The notion of a UTM guarantees that when N steps of D are correctly
>> simulated by H that this <is> the actual behavior that D specifies to H.
>
> The notion of a UTM is entirely irrelevant since your H and D aren't
> formulated in terms of Turing Machines in the first place. No where does
> your code involve a TM, let alone a UTM.
>
> The notion of a UTM is simply that it is possible to construct a single
> TM which can mimic the behaviour of all other TMs. It says nothing
> whatsoever about making *decisions* about the properties of those TMs.
>
> André
>

It says more than that. It says that the correct simulation of a machine
description does provide the underlying behavior specified by this
machine description.

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

When embedded_H is a simulating halt decider and

Ĥ is applied to ⟨Ĥ⟩
(q0) The input ⟨Ĥ⟩ is copied then transitions to embedded_H
embedded_H is applied to ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy)
which simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ which begins at its own (q0) to
repeat the process. (never reaching the simulated ⟨Ĥ.qn⟩ and halting).

The notion of a UTM guarantees that when N steps of ⟨Ĥ⟩ are correctly
simulated by embedded_H that this <is> the actual behavior that ⟨Ĥ⟩
specifies to embedded_H.

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

On 2023-04-08 17:00, olcott wrote:
> On 4/8/2023 4:39 PM, André G. Isaak wrote:
>> On 2023-04-08 15:14, olcott wrote:
>>> On 4/8/2023 3:43 PM, olcott wrote:
>>>> On 4/8/2023 3:22 PM, André G. Isaak wrote:
>>>>> On 2023-04-08 14:10, Ben Bacarisse wrote:
>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>
>>>>>>> On 4/7/23 8:37 PM, olcott wrote:
>>>>>>
>>>>>>>> A masters degree in EE is probably not nearly as much CS as a
>>>>>>>> BSBS in CS.
>>>>>>>
>>>>>>> You think so? Rmmember, my Masters was in Electrical Engineering and
>>>>>>> Computer Science, so I did get a lot of CS material too.
>>>>>>
>>>>>> Is PO saying he has a double BS degree?  You couldn't make it up!
>>>>>
>>>>> I think he means BS in Bullshit.
>>>>>
>>>>> André
>>>>>
>>>>
>>>> 01 int D(int (*x)())
>>>> 02 {
>>>> 03  int Halt_Status = H(x, x);
>>>> 04  if (Halt_Status)
>>>> 05    HERE: goto HERE;
>>>> 06  return Halt_Status;
>>>> 07 }
>>>> 08
>>>> 09 void main()
>>>> 10 {
>>>> 11  H(D,D);
>>>> 12 }
>>>>
>>>> Every halt decider must report on the actual behavior of its actual
>>>> input. The notion of a UTM establishes that H is correct to base its
>>>> halt status decision on a finite number of steps of D correctly
>>>> simulated by H.
>>>>
>>>
>>> The notion of a UTM guarantees that when N steps of D are correctly
>>> simulated by H that this <is> the actual behavior that D specifies to H.
>>
>> The notion of a UTM is entirely irrelevant since your H and D aren't
>> formulated in terms of Turing Machines in the first place. No where
>> does your code involve a TM, let alone a UTM.
>>
>> The notion of a UTM is simply that it is possible to construct a
>> single TM which can mimic the behaviour of all other TMs. It says
>> nothing whatsoever about making *decisions* about the properties of
>> those TMs.
>>
>> André
>>
>
>
> It says more than that. It says that the correct simulation of a machine
> description does provide the underlying behavior specified by this
> machine description.
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> When embedded_H is a simulating halt decider and
>
> Ĥ is applied to ⟨Ĥ⟩
> (q0) The input ⟨Ĥ⟩ is copied then transitions to embedded_H
> embedded_H is applied to ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy)
> which simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ which begins at its own (q0) to
> repeat the process. (never reaching the simulated ⟨Ĥ.qn⟩ and halting).

Since there is no mention of a UTM anywhere in the above, how can you
claim that the 'notion of a UTM' makes any claims whatsoever about the
above?!?

> The notion of a UTM guarantees that when N steps of ⟨Ĥ⟩ are correctly
> simulated by embedded_H that this <is> the actual behavior that ⟨Ĥ⟩
> specifies to embedded_H.

Non sequitur. embedded_H is not a UTM.

André

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

On 4/8/23 7:00 PM, olcott wrote:
> On 4/8/2023 4:39 PM, André G. Isaak wrote:
>> On 2023-04-08 15:14, olcott wrote:
>>> On 4/8/2023 3:43 PM, olcott wrote:
>>>> On 4/8/2023 3:22 PM, André G. Isaak wrote:
>>>>> On 2023-04-08 14:10, Ben Bacarisse wrote:
>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>
>>>>>>> On 4/7/23 8:37 PM, olcott wrote:
>>>>>>
>>>>>>>> A masters degree in EE is probably not nearly as much CS as a
>>>>>>>> BSBS in CS.
>>>>>>>
>>>>>>> You think so? Rmmember, my Masters was in Electrical Engineering and
>>>>>>> Computer Science, so I did get a lot of CS material too.
>>>>>>
>>>>>> Is PO saying he has a double BS degree?  You couldn't make it up!
>>>>>
>>>>> I think he means BS in Bullshit.
>>>>>
>>>>> André
>>>>>
>>>>
>>>> 01 int D(int (*x)())
>>>> 02 {
>>>> 03  int Halt_Status = H(x, x);
>>>> 04  if (Halt_Status)
>>>> 05    HERE: goto HERE;
>>>> 06  return Halt_Status;
>>>> 07 }
>>>> 08
>>>> 09 void main()
>>>> 10 {
>>>> 11  H(D,D);
>>>> 12 }
>>>>
>>>> Every halt decider must report on the actual behavior of its actual
>>>> input. The notion of a UTM establishes that H is correct to base its
>>>> halt status decision on a finite number of steps of D correctly
>>>> simulated by H.
>>>>
>>>
>>> The notion of a UTM guarantees that when N steps of D are correctly
>>> simulated by H that this <is> the actual behavior that D specifies to H.
>>
>> The notion of a UTM is entirely irrelevant since your H and D aren't
>> formulated in terms of Turing Machines in the first place. No where
>> does your code involve a TM, let alone a UTM.
>>
>> The notion of a UTM is simply that it is possible to construct a
>> single TM which can mimic the behaviour of all other TMs. It says
>> nothing whatsoever about making *decisions* about the properties of
>> those TMs.
>>
>> André
>>
>
>
> It says more than that. It says that the correct simulation of a machine
> description does provide the underlying behavior specified by this
> machine description.

It says the COMPLETE and CORRECT simulation of a machine description
provdies the underlying behavior specified by a machine desciption.

>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> When embedded_H is a simulating halt decider and
>
> Ĥ is applied to ⟨Ĥ⟩
> (q0) The input ⟨Ĥ⟩ is copied then transitions to embedded_H
> embedded_H is applied to ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy)
> which simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ which begins at its own (q0) to
> repeat the process. (never reaching the simulated ⟨Ĥ.qn⟩ and halting).

Which only happens *IF* H never aborts its simulation, but that
assumption isn't true. IF H EVER aborts its simulation, so will
embedded_H when used by Ĥ, which means that the loop is NOT "infinite"
and thus embedded_H will return to Ĥ to Ĥ.qn and Ĥ will Halt showing tht
it is the wrong answer.

You just don't understand how this works, so fail.

>
> The notion of a UTM guarantees that when N steps of ⟨Ĥ⟩ are correctly
> simulated by embedded_H that this <is> the actual behavior that ⟨Ĥ⟩
> specifies to embedded_H.
>

Except that the behavior of the first N steps of a machine don't
necesssarily tell you the eventual behavior of the machine.

FAIL.

On 4/8/23 7:09 PM, André G. Isaak wrote:
> On 2023-04-08 17:00, olcott wrote:
>> On 4/8/2023 4:39 PM, André G. Isaak wrote:
>>> On 2023-04-08 15:14, olcott wrote:
>>>> On 4/8/2023 3:43 PM, olcott wrote:
>>>>> On 4/8/2023 3:22 PM, André G. Isaak wrote:
>>>>>> On 2023-04-08 14:10, Ben Bacarisse wrote:
>>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>>
>>>>>>>> On 4/7/23 8:37 PM, olcott wrote:
>>>>>>>
>>>>>>>>> A masters degree in EE is probably not nearly as much CS as a
>>>>>>>>> BSBS in CS.
>>>>>>>>
>>>>>>>> You think so? Rmmember, my Masters was in Electrical Engineering
>>>>>>>> and
>>>>>>>> Computer Science, so I did get a lot of CS material too.
>>>>>>>
>>>>>>> Is PO saying he has a double BS degree?  You couldn't make it up!
>>>>>>
>>>>>> I think he means BS in Bullshit.
>>>>>>
>>>>>> André
>>>>>>
>>>>>
>>>>> 01 int D(int (*x)())
>>>>> 02 {
>>>>> 03  int Halt_Status = H(x, x);
>>>>> 04  if (Halt_Status)
>>>>> 05    HERE: goto HERE;
>>>>> 06  return Halt_Status;
>>>>> 07 }
>>>>> 08
>>>>> 09 void main()
>>>>> 10 {
>>>>> 11  H(D,D);
>>>>> 12 }
>>>>>
>>>>> Every halt decider must report on the actual behavior of its actual
>>>>> input. The notion of a UTM establishes that H is correct to base its
>>>>> halt status decision on a finite number of steps of D correctly
>>>>> simulated by H.
>>>>>
>>>>
>>>> The notion of a UTM guarantees that when N steps of D are correctly
>>>> simulated by H that this <is> the actual behavior that D specifies
>>>> to H.
>>>
>>> The notion of a UTM is entirely irrelevant since your H and D aren't
>>> formulated in terms of Turing Machines in the first place. No where
>>> does your code involve a TM, let alone a UTM.
>>>
>>> The notion of a UTM is simply that it is possible to construct a
>>> single TM which can mimic the behaviour of all other TMs. It says
>>> nothing whatsoever about making *decisions* about the properties of
>>> those TMs.
>>>
>>> André
>>>
>>
>>
>> It says more than that. It says that the correct simulation of a machine
>> description does provide the underlying behavior specified by this
>> machine description.
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> When embedded_H is a simulating halt decider and
>>
>> Ĥ is applied to ⟨Ĥ⟩
>> (q0) The input ⟨Ĥ⟩ is copied then transitions to embedded_H
>> embedded_H is applied to ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy)
>> which simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ which begins at its own (q0) to
>> repeat the process. (never reaching the simulated ⟨Ĥ.qn⟩ and halting).
>
> Since there is no mention of a UTM anywhere in the above, how can you
> claim that the 'notion of a UTM' makes any claims whatsoever about the
> above?!?
>
>> The notion of a UTM guarantees that when N steps of ⟨Ĥ⟩ are correctly
>> simulated by embedded_H that this <is> the actual behavior that ⟨Ĥ⟩
>> specifies to embedded_H.
>
> Non sequitur. embedded_H is not a UTM.
>
> André
>

Except that he thinks it is, but it is also a copy of H, and both of
these contradictions exist at the same time in is mind driving him
insane (which was always a short trip).

On 4/8/2023 6:09 PM, André G. Isaak wrote:
> On 2023-04-08 17:00, olcott wrote:
>> On 4/8/2023 4:39 PM, André G. Isaak wrote:
>>> On 2023-04-08 15:14, olcott wrote:
>>>> On 4/8/2023 3:43 PM, olcott wrote:
>>>>> On 4/8/2023 3:22 PM, André G. Isaak wrote:
>>>>>> On 2023-04-08 14:10, Ben Bacarisse wrote:
>>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>>
>>>>>>>> On 4/7/23 8:37 PM, olcott wrote:
>>>>>>>
>>>>>>>>> A masters degree in EE is probably not nearly as much CS as a
>>>>>>>>> BSBS in CS.
>>>>>>>>
>>>>>>>> You think so? Rmmember, my Masters was in Electrical Engineering
>>>>>>>> and
>>>>>>>> Computer Science, so I did get a lot of CS material too.
>>>>>>>
>>>>>>> Is PO saying he has a double BS degree?  You couldn't make it up!
>>>>>>
>>>>>> I think he means BS in Bullshit.
>>>>>>
>>>>>> André
>>>>>>
>>>>>
>>>>> 01 int D(int (*x)())
>>>>> 02 {
>>>>> 03  int Halt_Status = H(x, x);
>>>>> 04  if (Halt_Status)
>>>>> 05    HERE: goto HERE;
>>>>> 06  return Halt_Status;
>>>>> 07 }
>>>>> 08
>>>>> 09 void main()
>>>>> 10 {
>>>>> 11  H(D,D);
>>>>> 12 }
>>>>>
>>>>> Every halt decider must report on the actual behavior of its actual
>>>>> input. The notion of a UTM establishes that H is correct to base its
>>>>> halt status decision on a finite number of steps of D correctly
>>>>> simulated by H.
>>>>>
>>>>
>>>> The notion of a UTM guarantees that when N steps of D are correctly
>>>> simulated by H that this <is> the actual behavior that D specifies
>>>> to H.
>>>
>>> The notion of a UTM is entirely irrelevant since your H and D aren't
>>> formulated in terms of Turing Machines in the first place. No where
>>> does your code involve a TM, let alone a UTM.
>>>
>>> The notion of a UTM is simply that it is possible to construct a
>>> single TM which can mimic the behaviour of all other TMs. It says
>>> nothing whatsoever about making *decisions* about the properties of
>>> those TMs.
>>>
>>> André
>>>
>>
>>
>> It says more than that. It says that the correct simulation of a machine
>> description does provide the underlying behavior specified by this
>> machine description.
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> When embedded_H is a simulating halt decider and
>>
>> Ĥ is applied to ⟨Ĥ⟩
>> (q0) The input ⟨Ĥ⟩ is copied then transitions to embedded_H
>> embedded_H is applied to ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy)
>> which simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ which begins at its own (q0) to
>> repeat the process. (never reaching the simulated ⟨Ĥ.qn⟩ and halting).
>
> Since there is no mention of a UTM anywhere in the above, how can you
> claim that the 'notion of a UTM' makes any claims whatsoever about the
> above?!?
>
>> The notion of a UTM guarantees that when N steps of ⟨Ĥ⟩ are correctly
>> simulated by embedded_H that this <is> the actual behavior that ⟨Ĥ⟩
>> specifies to embedded_H.
>
> Non sequitur. embedded_H is not a UTM.

That it is more than a UTM does not negate its UTM properties.

The notion of a UTM conclusively proves that N steps of ⟨Ĥ⟩ correctly
simulated by embedded_H does provide the actual behavior that ⟨Ĥ⟩
presents to embedded_H.

>
> André
>

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

On 4/8/23 7:26 PM, olcott wrote:
> On 4/8/2023 6:09 PM, André G. Isaak wrote:
>> On 2023-04-08 17:00, olcott wrote:
>>> On 4/8/2023 4:39 PM, André G. Isaak wrote:
>>>> On 2023-04-08 15:14, olcott wrote:
>>>>> On 4/8/2023 3:43 PM, olcott wrote:
>>>>>> On 4/8/2023 3:22 PM, André G. Isaak wrote:
>>>>>>> On 2023-04-08 14:10, Ben Bacarisse wrote:
>>>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>>>
>>>>>>>>> On 4/7/23 8:37 PM, olcott wrote:
>>>>>>>>
>>>>>>>>>> A masters degree in EE is probably not nearly as much CS as a
>>>>>>>>>> BSBS in CS.
>>>>>>>>>
>>>>>>>>> You think so? Rmmember, my Masters was in Electrical
>>>>>>>>> Engineering and
>>>>>>>>> Computer Science, so I did get a lot of CS material too.
>>>>>>>>
>>>>>>>> Is PO saying he has a double BS degree?  You couldn't make it up!
>>>>>>>
>>>>>>> I think he means BS in Bullshit.
>>>>>>>
>>>>>>> André
>>>>>>>
>>>>>>
>>>>>> 01 int D(int (*x)())
>>>>>> 02 {
>>>>>> 03  int Halt_Status = H(x, x);
>>>>>> 04  if (Halt_Status)
>>>>>> 05    HERE: goto HERE;
>>>>>> 06  return Halt_Status;
>>>>>> 07 }
>>>>>> 08
>>>>>> 09 void main()
>>>>>> 10 {
>>>>>> 11  H(D,D);
>>>>>> 12 }
>>>>>>
>>>>>> Every halt decider must report on the actual behavior of its actual
>>>>>> input. The notion of a UTM establishes that H is correct to base its
>>>>>> halt status decision on a finite number of steps of D correctly
>>>>>> simulated by H.
>>>>>>
>>>>>
>>>>> The notion of a UTM guarantees that when N steps of D are correctly
>>>>> simulated by H that this <is> the actual behavior that D specifies
>>>>> to H.
>>>>
>>>> The notion of a UTM is entirely irrelevant since your H and D aren't
>>>> formulated in terms of Turing Machines in the first place. No where
>>>> does your code involve a TM, let alone a UTM.
>>>>
>>>> The notion of a UTM is simply that it is possible to construct a
>>>> single TM which can mimic the behaviour of all other TMs. It says
>>>> nothing whatsoever about making *decisions* about the properties of
>>>> those TMs.
>>>>
>>>> André
>>>>
>>>
>>>
>>> It says more than that. It says that the correct simulation of a machine
>>> description does provide the underlying behavior specified by this
>>> machine description.
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> When embedded_H is a simulating halt decider and
>>>
>>> Ĥ is applied to ⟨Ĥ⟩
>>> (q0) The input ⟨Ĥ⟩ is copied then transitions to embedded_H
>>> embedded_H is applied to ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy)
>>> which simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ which begins at its own (q0) to
>>> repeat the process. (never reaching the simulated ⟨Ĥ.qn⟩ and halting).
>>
>> Since there is no mention of a UTM anywhere in the above, how can you
>> claim that the 'notion of a UTM' makes any claims whatsoever about the
>> above?!?
>>
>>> The notion of a UTM guarantees that when N steps of ⟨Ĥ⟩ are correctly
>>> simulated by embedded_H that this <is> the actual behavior that ⟨Ĥ⟩
>>> specifies to embedded_H.
>>
>> Non sequitur. embedded_H is not a UTM.
>
> That it is more than a UTM does not negate its UTM properties.

But it doesn't HAVE the basic UTM property of recreating the ENTIRE
behavior of its input, which requires that it never stops.

NOT A UTM is NOT A UTM.

>
> The notion of a UTM conclusively proves that N steps of ⟨Ĥ⟩ correctly
> simulated by embedded_H does provide the actual behavior that ⟨Ĥ⟩
> presents to embedded_H.

Nope.

SHOW THE PROOF. TRY IT, you don't know how to.

Your BLUFF is CALLED.

Remember, a PROOF begins with a listing of the ACCEPTED TRUTHS that the
fields has that you are starting with.

Remember to give you SOURCE for these truths.

If you want to say something is "true by the meaning of the words", you
need to quote the TECHNICAL meaning of the words that show it.

>
>>
>> André
>>
>

On 2023-04-08 17:26, olcott wrote:
> On 4/8/2023 6:09 PM, André G. Isaak wrote:
>> On 2023-04-08 17:00, olcott wrote:
>>> On 4/8/2023 4:39 PM, André G. Isaak wrote:
>>>> On 2023-04-08 15:14, olcott wrote:
>>>>> On 4/8/2023 3:43 PM, olcott wrote:
>>>>>> On 4/8/2023 3:22 PM, André G. Isaak wrote:
>>>>>>> On 2023-04-08 14:10, Ben Bacarisse wrote:
>>>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>>>
>>>>>>>>> On 4/7/23 8:37 PM, olcott wrote:
>>>>>>>>
>>>>>>>>>> A masters degree in EE is probably not nearly as much CS as a
>>>>>>>>>> BSBS in CS.
>>>>>>>>>
>>>>>>>>> You think so? Rmmember, my Masters was in Electrical
>>>>>>>>> Engineering and
>>>>>>>>> Computer Science, so I did get a lot of CS material too.
>>>>>>>>
>>>>>>>> Is PO saying he has a double BS degree?  You couldn't make it up!
>>>>>>>
>>>>>>> I think he means BS in Bullshit.
>>>>>>>
>>>>>>> André
>>>>>>>
>>>>>>
>>>>>> 01 int D(int (*x)())
>>>>>> 02 {
>>>>>> 03  int Halt_Status = H(x, x);
>>>>>> 04  if (Halt_Status)
>>>>>> 05    HERE: goto HERE;
>>>>>> 06  return Halt_Status;
>>>>>> 07 }
>>>>>> 08
>>>>>> 09 void main()
>>>>>> 10 {
>>>>>> 11  H(D,D);
>>>>>> 12 }
>>>>>>
>>>>>> Every halt decider must report on the actual behavior of its actual
>>>>>> input. The notion of a UTM establishes that H is correct to base its
>>>>>> halt status decision on a finite number of steps of D correctly
>>>>>> simulated by H.
>>>>>>
>>>>>
>>>>> The notion of a UTM guarantees that when N steps of D are correctly
>>>>> simulated by H that this <is> the actual behavior that D specifies
>>>>> to H.
>>>>
>>>> The notion of a UTM is entirely irrelevant since your H and D aren't
>>>> formulated in terms of Turing Machines in the first place. No where
>>>> does your code involve a TM, let alone a UTM.
>>>>
>>>> The notion of a UTM is simply that it is possible to construct a
>>>> single TM which can mimic the behaviour of all other TMs. It says
>>>> nothing whatsoever about making *decisions* about the properties of
>>>> those TMs.
>>>>
>>>> André
>>>>
>>>
>>>
>>> It says more than that. It says that the correct simulation of a machine
>>> description does provide the underlying behavior specified by this
>>> machine description.
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> When embedded_H is a simulating halt decider and
>>>
>>> Ĥ is applied to ⟨Ĥ⟩
>>> (q0) The input ⟨Ĥ⟩ is copied then transitions to embedded_H
>>> embedded_H is applied to ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy)
>>> which simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ which begins at its own (q0) to
>>> repeat the process. (never reaching the simulated ⟨Ĥ.qn⟩ and halting).
>>
>> Since there is no mention of a UTM anywhere in the above, how can you
>> claim that the 'notion of a UTM' makes any claims whatsoever about the
>> above?!?
>>
>>> The notion of a UTM guarantees that when N steps of ⟨Ĥ⟩ are correctly
>>> simulated by embedded_H that this <is> the actual behavior that ⟨Ĥ⟩
>>> specifies to embedded_H.
>>
>> Non sequitur. embedded_H is not a UTM.
>
> That it is more than a UTM does not negate its UTM properties.

It is not a UTM at all.

A UTM applied to (X, Y) answers the question 'what result does TM X give
if applied to string Y?'

A halt decider applied to (X, Y) answers the question 'does TM X applied
to string Y halt?'

The two are mutually exclusive.

And embedded_H is *neither* of the above things.

André

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

On 4/8/2023 6:37 PM, André G. Isaak wrote:
> On 2023-04-08 17:26, olcott wrote:
>> On 4/8/2023 6:09 PM, André G. Isaak wrote:
>>> On 2023-04-08 17:00, olcott wrote:
>>>> On 4/8/2023 4:39 PM, André G. Isaak wrote:
>>>>> On 2023-04-08 15:14, olcott wrote:
>>>>>> On 4/8/2023 3:43 PM, olcott wrote:
>>>>>>> On 4/8/2023 3:22 PM, André G. Isaak wrote:
>>>>>>>> On 2023-04-08 14:10, Ben Bacarisse wrote:
>>>>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>>>>
>>>>>>>>>> On 4/7/23 8:37 PM, olcott wrote:
>>>>>>>>>
>>>>>>>>>>> A masters degree in EE is probably not nearly as much CS as a
>>>>>>>>>>> BSBS in CS.
>>>>>>>>>>
>>>>>>>>>> You think so? Rmmember, my Masters was in Electrical
>>>>>>>>>> Engineering and
>>>>>>>>>> Computer Science, so I did get a lot of CS material too.
>>>>>>>>>
>>>>>>>>> Is PO saying he has a double BS degree?  You couldn't make it up!
>>>>>>>>
>>>>>>>> I think he means BS in Bullshit.
>>>>>>>>
>>>>>>>> André
>>>>>>>>
>>>>>>>
>>>>>>> 01 int D(int (*x)())
>>>>>>> 02 {
>>>>>>> 03  int Halt_Status = H(x, x);
>>>>>>> 04  if (Halt_Status)
>>>>>>> 05    HERE: goto HERE;
>>>>>>> 06  return Halt_Status;
>>>>>>> 07 }
>>>>>>> 08
>>>>>>> 09 void main()
>>>>>>> 10 {
>>>>>>> 11  H(D,D);
>>>>>>> 12 }
>>>>>>>
>>>>>>> Every halt decider must report on the actual behavior of its actual
>>>>>>> input. The notion of a UTM establishes that H is correct to base its
>>>>>>> halt status decision on a finite number of steps of D correctly
>>>>>>> simulated by H.
>>>>>>>
>>>>>>
>>>>>> The notion of a UTM guarantees that when N steps of D are correctly
>>>>>> simulated by H that this <is> the actual behavior that D specifies
>>>>>> to H.
>>>>>
>>>>> The notion of a UTM is entirely irrelevant since your H and D
>>>>> aren't formulated in terms of Turing Machines in the first place.
>>>>> No where does your code involve a TM, let alone a UTM.
>>>>>
>>>>> The notion of a UTM is simply that it is possible to construct a
>>>>> single TM which can mimic the behaviour of all other TMs. It says
>>>>> nothing whatsoever about making *decisions* about the properties of
>>>>> those TMs.
>>>>>
>>>>> André
>>>>>
>>>>
>>>>
>>>> It says more than that. It says that the correct simulation of a
>>>> machine
>>>> description does provide the underlying behavior specified by this
>>>> machine description.
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> When embedded_H is a simulating halt decider and
>>>>
>>>> Ĥ is applied to ⟨Ĥ⟩
>>>> (q0) The input ⟨Ĥ⟩ is copied then transitions to embedded_H
>>>> embedded_H is applied to ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy)
>>>> which simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ which begins at its own (q0) to
>>>> repeat the process. (never reaching the simulated ⟨Ĥ.qn⟩ and halting).
>>>
>>> Since there is no mention of a UTM anywhere in the above, how can you
>>> claim that the 'notion of a UTM' makes any claims whatsoever about
>>> the above?!?
>>>
>>>> The notion of a UTM guarantees that when N steps of ⟨Ĥ⟩ are correctly
>>>> simulated by embedded_H that this <is> the actual behavior that ⟨Ĥ⟩
>>>> specifies to embedded_H.
>>>
>>> Non sequitur. embedded_H is not a UTM.
>>
>> That it is more than a UTM does not negate its UTM properties.
>
> It is not a UTM at all.
>

A simulating halt decider starts with a UTM and then augments it with
additional features.

It is like saying that when you put a hat on a horse the horse becomes a
cow and is no longer any sort of horse at all.

The additional features are that it examines the behavior of its
simulated input and determines whether or not this behavior matches a
know non-halting behavior pattern.

When we simply add those two features to a UTM then we know that N steps
of ⟨Ĥ⟩ are correctly simulated by embedded_H do provide the actual
behavior that ⟨Ĥ⟩ presents to embedded_H.

> A UTM applied to (X, Y) answers the question 'what result does TM X give
> if applied to string Y?'
>
> A halt decider applied to (X, Y) answers the question 'does TM X applied
> to string Y halt?'
>
> The two are mutually exclusive.
>
> And embedded_H is *neither* of the above things.
>
> André
>

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

On 4/8/2023 6:37 PM, André G. Isaak wrote:
> On 2023-04-08 17:26, olcott wrote:
>> On 4/8/2023 6:09 PM, André G. Isaak wrote:
>>> On 2023-04-08 17:00, olcott wrote:
>>>> On 4/8/2023 4:39 PM, André G. Isaak wrote:
>>>>> On 2023-04-08 15:14, olcott wrote:
>>>>>> On 4/8/2023 3:43 PM, olcott wrote:
>>>>>>> On 4/8/2023 3:22 PM, André G. Isaak wrote:
>>>>>>>> On 2023-04-08 14:10, Ben Bacarisse wrote:
>>>>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>>>>
>>>>>>>>>> On 4/7/23 8:37 PM, olcott wrote:
>>>>>>>>>
>>>>>>>>>>> A masters degree in EE is probably not nearly as much CS as a
>>>>>>>>>>> BSBS in CS.
>>>>>>>>>>
>>>>>>>>>> You think so? Rmmember, my Masters was in Electrical
>>>>>>>>>> Engineering and
>>>>>>>>>> Computer Science, so I did get a lot of CS material too.
>>>>>>>>>
>>>>>>>>> Is PO saying he has a double BS degree?  You couldn't make it up!
>>>>>>>>
>>>>>>>> I think he means BS in Bullshit.
>>>>>>>>
>>>>>>>> André
>>>>>>>>
>>>>>>>
>>>>>>> 01 int D(int (*x)())
>>>>>>> 02 {
>>>>>>> 03  int Halt_Status = H(x, x);
>>>>>>> 04  if (Halt_Status)
>>>>>>> 05    HERE: goto HERE;
>>>>>>> 06  return Halt_Status;
>>>>>>> 07 }
>>>>>>> 08
>>>>>>> 09 void main()
>>>>>>> 10 {
>>>>>>> 11  H(D,D);
>>>>>>> 12 }
>>>>>>>
>>>>>>> Every halt decider must report on the actual behavior of its actual
>>>>>>> input. The notion of a UTM establishes that H is correct to base its
>>>>>>> halt status decision on a finite number of steps of D correctly
>>>>>>> simulated by H.
>>>>>>>
>>>>>>
>>>>>> The notion of a UTM guarantees that when N steps of D are correctly
>>>>>> simulated by H that this <is> the actual behavior that D specifies
>>>>>> to H.
>>>>>
>>>>> The notion of a UTM is entirely irrelevant since your H and D
>>>>> aren't formulated in terms of Turing Machines in the first place.
>>>>> No where does your code involve a TM, let alone a UTM.
>>>>>
>>>>> The notion of a UTM is simply that it is possible to construct a
>>>>> single TM which can mimic the behaviour of all other TMs. It says
>>>>> nothing whatsoever about making *decisions* about the properties of
>>>>> those TMs.
>>>>>
>>>>> André
>>>>>
>>>>
>>>>
>>>> It says more than that. It says that the correct simulation of a
>>>> machine
>>>> description does provide the underlying behavior specified by this
>>>> machine description.
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> When embedded_H is a simulating halt decider and
>>>>
>>>> Ĥ is applied to ⟨Ĥ⟩
>>>> (q0) The input ⟨Ĥ⟩ is copied then transitions to embedded_H
>>>> embedded_H is applied to ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy)
>>>> which simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ which begins at its own (q0) to
>>>> repeat the process. (never reaching the simulated ⟨Ĥ.qn⟩ and halting).
>>>
>>> Since there is no mention of a UTM anywhere in the above, how can you
>>> claim that the 'notion of a UTM' makes any claims whatsoever about
>>> the above?!?
>>>
>>>> The notion of a UTM guarantees that when N steps of ⟨Ĥ⟩ are correctly
>>>> simulated by embedded_H that this <is> the actual behavior that ⟨Ĥ⟩
>>>> specifies to embedded_H.
>>>
>>> Non sequitur. embedded_H is not a UTM.
>>
>> That it is more than a UTM does not negate its UTM properties.
>
> It is not a UTM at all.
>

A simulating halt decider starts with a UTM and then augments it with
additional features.

It is like [YOU ARE] saying that when you put a hat on a horse the horse
becomes a cow and is no longer any sort of horse at all.

The additional features are that it examines the behavior of its
simulated input and determines whether or not this behavior matches a
known non-halting behavior pattern.

When we simply add those two features to a UTM then we know that N steps
of ⟨Ĥ⟩ are correctly simulated by embedded_H do provide the actual
behavior that ⟨Ĥ⟩ presents to embedded_H.

> A UTM applied to (X, Y) answers the question 'what result does TM X give
> if applied to string Y?'
>
> A halt decider applied to (X, Y) answers the question 'does TM X applied
> to string Y halt?'
>
> The two are mutually exclusive.
>
> And embedded_H is *neither* of the above things.
>
> André
>

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

On 4/8/23 7:47 PM, olcott wrote:
> On 4/8/2023 6:37 PM, André G. Isaak wrote:
>> On 2023-04-08 17:26, olcott wrote:
>>> On 4/8/2023 6:09 PM, André G. Isaak wrote:
>>>> On 2023-04-08 17:00, olcott wrote:
>>>>> On 4/8/2023 4:39 PM, André G. Isaak wrote:
>>>>>> On 2023-04-08 15:14, olcott wrote:
>>>>>>> On 4/8/2023 3:43 PM, olcott wrote:
>>>>>>>> On 4/8/2023 3:22 PM, André G. Isaak wrote:
>>>>>>>>> On 2023-04-08 14:10, Ben Bacarisse wrote:
>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>>>>>
>>>>>>>>>>> On 4/7/23 8:37 PM, olcott wrote:
>>>>>>>>>>
>>>>>>>>>>>> A masters degree in EE is probably not nearly as much CS as
>>>>>>>>>>>> a BSBS in CS.
>>>>>>>>>>>
>>>>>>>>>>> You think so? Rmmember, my Masters was in Electrical
>>>>>>>>>>> Engineering and
>>>>>>>>>>> Computer Science, so I did get a lot of CS material too.
>>>>>>>>>>
>>>>>>>>>> Is PO saying he has a double BS degree?  You couldn't make it up!
>>>>>>>>>
>>>>>>>>> I think he means BS in Bullshit.
>>>>>>>>>
>>>>>>>>> André
>>>>>>>>>
>>>>>>>>
>>>>>>>> 01 int D(int (*x)())
>>>>>>>> 02 {
>>>>>>>> 03  int Halt_Status = H(x, x);
>>>>>>>> 04  if (Halt_Status)
>>>>>>>> 05    HERE: goto HERE;
>>>>>>>> 06  return Halt_Status;
>>>>>>>> 07 }
>>>>>>>> 08
>>>>>>>> 09 void main()
>>>>>>>> 10 {
>>>>>>>> 11  H(D,D);
>>>>>>>> 12 }
>>>>>>>>
>>>>>>>> Every halt decider must report on the actual behavior of its actual
>>>>>>>> input. The notion of a UTM establishes that H is correct to base
>>>>>>>> its
>>>>>>>> halt status decision on a finite number of steps of D correctly
>>>>>>>> simulated by H.
>>>>>>>>
>>>>>>>
>>>>>>> The notion of a UTM guarantees that when N steps of D are correctly
>>>>>>> simulated by H that this <is> the actual behavior that D
>>>>>>> specifies to H.
>>>>>>
>>>>>> The notion of a UTM is entirely irrelevant since your H and D
>>>>>> aren't formulated in terms of Turing Machines in the first place.
>>>>>> No where does your code involve a TM, let alone a UTM.
>>>>>>
>>>>>> The notion of a UTM is simply that it is possible to construct a
>>>>>> single TM which can mimic the behaviour of all other TMs. It says
>>>>>> nothing whatsoever about making *decisions* about the properties
>>>>>> of those TMs.
>>>>>>
>>>>>> André
>>>>>>
>>>>>
>>>>>
>>>>> It says more than that. It says that the correct simulation of a
>>>>> machine
>>>>> description does provide the underlying behavior specified by this
>>>>> machine description.
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> When embedded_H is a simulating halt decider and
>>>>>
>>>>> Ĥ is applied to ⟨Ĥ⟩
>>>>> (q0) The input ⟨Ĥ⟩ is copied then transitions to embedded_H
>>>>> embedded_H is applied to ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy)
>>>>> which simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ which begins at its own (q0) to
>>>>> repeat the process. (never reaching the simulated ⟨Ĥ.qn⟩ and halting).
>>>>
>>>> Since there is no mention of a UTM anywhere in the above, how can
>>>> you claim that the 'notion of a UTM' makes any claims whatsoever
>>>> about the above?!?
>>>>
>>>>> The notion of a UTM guarantees that when N steps of ⟨Ĥ⟩ are correctly
>>>>> simulated by embedded_H that this <is> the actual behavior that ⟨Ĥ⟩
>>>>> specifies to embedded_H.
>>>>
>>>> Non sequitur. embedded_H is not a UTM.
>>>
>>> That it is more than a UTM does not negate its UTM properties.
>>
>> It is not a UTM at all.
>>
>
> A simulating halt decider starts with a UTM and then augments it with
> additional features.

Nope, the way you describe it BREAKS it.
>
> It is like saying that when you put a hat on a horse the horse becomes a
> cow and is no longer any sort of horse at all.

Nope, it is like saying if you modify a street legal car for racing it
will still be street legal.

>
> The additional features are that it examines the behavior of its
> simulated input and determines whether or not this behavior matches a
> know non-halting behavior pattern.

That is ok. STOPING the simulation is not, as then it isn't a UTM.

>
> When we simply add those two features to a UTM then we know that N steps
> of ⟨Ĥ⟩ are correctly simulated by embedded_H do provide the actual
> behavior that ⟨Ĥ⟩ presents to embedded_H.

Nope, because you H assumes that the H that H^ used is actual a UTM,
when it isn't anymopre.

Thus, it gets the wrong answer.

Yes, you can perhaps use a UTM like technology to do a partial
simulation, you just can't use the fact that it was based on a UTM to
just assume you can predict the behavior from N steps.

You need to PROVE that, which you have failed to do.

By your failure to provide the proof requested, you are admitting that
you can't prove your assertaon.

This seems your SOP, but then you are the one that said it was ok for
you to have Child Porn since you were GOD.

>
>> A UTM applied to (X, Y) answers the question 'what result does TM X
>> give if applied to string Y?'
>>
>> A halt decider applied to (X, Y) answers the question 'does TM X
>> applied to string Y halt?'
>>
>> The two are mutually exclusive.
>>
>> And embedded_H is *neither* of the above things.
>>
>> André
>>
>

On 2023-04-08 17:47, olcott wrote:
> On 4/8/2023 6:37 PM, André G. Isaak wrote:
>> On 2023-04-08 17:26, olcott wrote:
>>> On 4/8/2023 6:09 PM, André G. Isaak wrote:
>>>> On 2023-04-08 17:00, olcott wrote:
>>>>> On 4/8/2023 4:39 PM, André G. Isaak wrote:
>>>>>> On 2023-04-08 15:14, olcott wrote:
>>>>>>> On 4/8/2023 3:43 PM, olcott wrote:
>>>>>>>> On 4/8/2023 3:22 PM, André G. Isaak wrote:
>>>>>>>>> On 2023-04-08 14:10, Ben Bacarisse wrote:
>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>>>>>
>>>>>>>>>>> On 4/7/23 8:37 PM, olcott wrote:
>>>>>>>>>>
>>>>>>>>>>>> A masters degree in EE is probably not nearly as much CS as
>>>>>>>>>>>> a BSBS in CS.
>>>>>>>>>>>
>>>>>>>>>>> You think so? Rmmember, my Masters was in Electrical
>>>>>>>>>>> Engineering and
>>>>>>>>>>> Computer Science, so I did get a lot of CS material too.
>>>>>>>>>>
>>>>>>>>>> Is PO saying he has a double BS degree?  You couldn't make it up!
>>>>>>>>>
>>>>>>>>> I think he means BS in Bullshit.
>>>>>>>>>
>>>>>>>>> André
>>>>>>>>>
>>>>>>>>
>>>>>>>> 01 int D(int (*x)())
>>>>>>>> 02 {
>>>>>>>> 03  int Halt_Status = H(x, x);
>>>>>>>> 04  if (Halt_Status)
>>>>>>>> 05    HERE: goto HERE;
>>>>>>>> 06  return Halt_Status;
>>>>>>>> 07 }
>>>>>>>> 08
>>>>>>>> 09 void main()
>>>>>>>> 10 {
>>>>>>>> 11  H(D,D);
>>>>>>>> 12 }
>>>>>>>>
>>>>>>>> Every halt decider must report on the actual behavior of its actual
>>>>>>>> input. The notion of a UTM establishes that H is correct to base
>>>>>>>> its
>>>>>>>> halt status decision on a finite number of steps of D correctly
>>>>>>>> simulated by H.
>>>>>>>>
>>>>>>>
>>>>>>> The notion of a UTM guarantees that when N steps of D are correctly
>>>>>>> simulated by H that this <is> the actual behavior that D
>>>>>>> specifies to H.
>>>>>>
>>>>>> The notion of a UTM is entirely irrelevant since your H and D
>>>>>> aren't formulated in terms of Turing Machines in the first place.
>>>>>> No where does your code involve a TM, let alone a UTM.
>>>>>>
>>>>>> The notion of a UTM is simply that it is possible to construct a
>>>>>> single TM which can mimic the behaviour of all other TMs. It says
>>>>>> nothing whatsoever about making *decisions* about the properties
>>>>>> of those TMs.
>>>>>>
>>>>>> André
>>>>>>
>>>>>
>>>>>
>>>>> It says more than that. It says that the correct simulation of a
>>>>> machine
>>>>> description does provide the underlying behavior specified by this
>>>>> machine description.
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> When embedded_H is a simulating halt decider and
>>>>>
>>>>> Ĥ is applied to ⟨Ĥ⟩
>>>>> (q0) The input ⟨Ĥ⟩ is copied then transitions to embedded_H
>>>>> embedded_H is applied to ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy)
>>>>> which simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ which begins at its own (q0) to
>>>>> repeat the process. (never reaching the simulated ⟨Ĥ.qn⟩ and halting).
>>>>
>>>> Since there is no mention of a UTM anywhere in the above, how can
>>>> you claim that the 'notion of a UTM' makes any claims whatsoever
>>>> about the above?!?
>>>>
>>>>> The notion of a UTM guarantees that when N steps of ⟨Ĥ⟩ are correctly
>>>>> simulated by embedded_H that this <is> the actual behavior that ⟨Ĥ⟩
>>>>> specifies to embedded_H.
>>>>
>>>> Non sequitur. embedded_H is not a UTM.
>>>
>>> That it is more than a UTM does not negate its UTM properties.
>>
>> It is not a UTM at all.
>>
>
> A simulating halt decider starts with a UTM and then augments it with
> additional features.

It doesn't "augment" it. It *changes* it. When given a non-halting
computation as its input, a UTM will run forever. A simulating halt
decider (were such a thing possible) on the other hand, would reject
this input and then HALT. This is entirely different from what a UTM does.

You can state that there is a *relationship* between your 'simulating
halt decider' and a UTM in that the SHD uses similar methods as a UTM to
(partially) simulate its input, but that doesn't mean you can
legitimately say an SHD *is* a UTM -- it is not (and of course since
your H and D are not even turing machines, it makes no sense to talk
about UTMs at all).

André

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

On 4/8/2023 7:53 PM, André G. Isaak wrote:
> On 2023-04-08 17:47, olcott wrote:
>> On 4/8/2023 6:37 PM, André G. Isaak wrote:
>>> On 2023-04-08 17:26, olcott wrote:
>>>> On 4/8/2023 6:09 PM, André G. Isaak wrote:
>>>>> On 2023-04-08 17:00, olcott wrote:
>>>>>> On 4/8/2023 4:39 PM, André G. Isaak wrote:
>>>>>>> On 2023-04-08 15:14, olcott wrote:
>>>>>>>> On 4/8/2023 3:43 PM, olcott wrote:
>>>>>>>>> On 4/8/2023 3:22 PM, André G. Isaak wrote:
>>>>>>>>>> On 2023-04-08 14:10, Ben Bacarisse wrote:
>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 4/7/23 8:37 PM, olcott wrote:
>>>>>>>>>>>
>>>>>>>>>>>>> A masters degree in EE is probably not nearly as much CS as
>>>>>>>>>>>>> a BSBS in CS.
>>>>>>>>>>>>
>>>>>>>>>>>> You think so? Rmmember, my Masters was in Electrical
>>>>>>>>>>>> Engineering and
>>>>>>>>>>>> Computer Science, so I did get a lot of CS material too.
>>>>>>>>>>>
>>>>>>>>>>> Is PO saying he has a double BS degree?  You couldn't make it
>>>>>>>>>>> up!
>>>>>>>>>>
>>>>>>>>>> I think he means BS in Bullshit.
>>>>>>>>>>
>>>>>>>>>> André
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> 01 int D(int (*x)())
>>>>>>>>> 02 {
>>>>>>>>> 03  int Halt_Status = H(x, x);
>>>>>>>>> 04  if (Halt_Status)
>>>>>>>>> 05    HERE: goto HERE;
>>>>>>>>> 06  return Halt_Status;
>>>>>>>>> 07 }
>>>>>>>>> 08
>>>>>>>>> 09 void main()
>>>>>>>>> 10 {
>>>>>>>>> 11  H(D,D);
>>>>>>>>> 12 }
>>>>>>>>>
>>>>>>>>> Every halt decider must report on the actual behavior of its
>>>>>>>>> actual
>>>>>>>>> input. The notion of a UTM establishes that H is correct to
>>>>>>>>> base its
>>>>>>>>> halt status decision on a finite number of steps of D correctly
>>>>>>>>> simulated by H.
>>>>>>>>>
>>>>>>>>
>>>>>>>> The notion of a UTM guarantees that when N steps of D are correctly
>>>>>>>> simulated by H that this <is> the actual behavior that D
>>>>>>>> specifies to H.
>>>>>>>
>>>>>>> The notion of a UTM is entirely irrelevant since your H and D
>>>>>>> aren't formulated in terms of Turing Machines in the first place.
>>>>>>> No where does your code involve a TM, let alone a UTM.
>>>>>>>
>>>>>>> The notion of a UTM is simply that it is possible to construct a
>>>>>>> single TM which can mimic the behaviour of all other TMs. It says
>>>>>>> nothing whatsoever about making *decisions* about the properties
>>>>>>> of those TMs.
>>>>>>>
>>>>>>> André
>>>>>>>
>>>>>>
>>>>>>
>>>>>> It says more than that. It says that the correct simulation of a
>>>>>> machine
>>>>>> description does provide the underlying behavior specified by this
>>>>>> machine description.
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> When embedded_H is a simulating halt decider and
>>>>>>
>>>>>> Ĥ is applied to ⟨Ĥ⟩
>>>>>> (q0) The input ⟨Ĥ⟩ is copied then transitions to embedded_H
>>>>>> embedded_H is applied to ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy)
>>>>>> which simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ which begins at its own (q0) to
>>>>>> repeat the process. (never reaching the simulated ⟨Ĥ.qn⟩ and
>>>>>> halting).
>>>>>
>>>>> Since there is no mention of a UTM anywhere in the above, how can
>>>>> you claim that the 'notion of a UTM' makes any claims whatsoever
>>>>> about the above?!?
>>>>>
>>>>>> The notion of a UTM guarantees that when N steps of ⟨Ĥ⟩ are correctly
>>>>>> simulated by embedded_H that this <is> the actual behavior that ⟨Ĥ⟩
>>>>>> specifies to embedded_H.
>>>>>
>>>>> Non sequitur. embedded_H is not a UTM.
>>>>
>>>> That it is more than a UTM does not negate its UTM properties.
>>>
>>> It is not a UTM at all.
>>>
>>
>> A simulating halt decider starts with a UTM and then augments it with
>> additional features.
>
> It doesn't "augment" it. It *changes* it. When given a non-halting
> computation as its input, a UTM will run forever.

It does not change the steps being simulated thus when N steps are
correctly simulated by embedded_H this does provide the actual behavior
of the actual input for these N steps.

When you and I can see that these N steps provide enough information to
determine that ⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly
reach its own simulated final state of ⟨Ĥ.qn⟩ this conclusively proves
that ⟨Ĥ⟩ presents non-halting behavior to embedded_H.

> A simulating halt
> decider (were such a thing possible) on the other hand, would reject
> this input and then HALT. This is entirely different from what a UTM does.
>
> You can state that there is a *relationship* between your 'simulating
> halt decider' and a UTM in that the SHD uses similar methods as a UTM to
> (partially) simulate its input, but that doesn't mean you can
> legitimately say an SHD *is* a UTM -- it is not (and of course since
> your H and D are not even turing machines, it makes no sense to talk
> about UTMs at all).
>
> André
>

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

On 4/8/23 9:17 PM, olcott wrote:
> On 4/8/2023 7:53 PM, André G. Isaak wrote:
>> On 2023-04-08 17:47, olcott wrote:
>>> On 4/8/2023 6:37 PM, André G. Isaak wrote:
>>>> On 2023-04-08 17:26, olcott wrote:
>>>>> On 4/8/2023 6:09 PM, André G. Isaak wrote:
>>>>>> On 2023-04-08 17:00, olcott wrote:
>>>>>>> On 4/8/2023 4:39 PM, André G. Isaak wrote:
>>>>>>>> On 2023-04-08 15:14, olcott wrote:
>>>>>>>>> On 4/8/2023 3:43 PM, olcott wrote:
>>>>>>>>>> On 4/8/2023 3:22 PM, André G. Isaak wrote:
>>>>>>>>>>> On 2023-04-08 14:10, Ben Bacarisse wrote:
>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 4/7/23 8:37 PM, olcott wrote:
>>>>>>>>>>>>
>>>>>>>>>>>>>> A masters degree in EE is probably not nearly as much CS
>>>>>>>>>>>>>> as a BSBS in CS.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You think so? Rmmember, my Masters was in Electrical
>>>>>>>>>>>>> Engineering and
>>>>>>>>>>>>> Computer Science, so I did get a lot of CS material too.
>>>>>>>>>>>>
>>>>>>>>>>>> Is PO saying he has a double BS degree?  You couldn't make
>>>>>>>>>>>> it up!
>>>>>>>>>>>
>>>>>>>>>>> I think he means BS in Bullshit.
>>>>>>>>>>>
>>>>>>>>>>> André
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> 01 int D(int (*x)())
>>>>>>>>>> 02 {
>>>>>>>>>> 03  int Halt_Status = H(x, x);
>>>>>>>>>> 04  if (Halt_Status)
>>>>>>>>>> 05    HERE: goto HERE;
>>>>>>>>>> 06  return Halt_Status;
>>>>>>>>>> 07 }
>>>>>>>>>> 08
>>>>>>>>>> 09 void main()
>>>>>>>>>> 10 {
>>>>>>>>>> 11  H(D,D);
>>>>>>>>>> 12 }
>>>>>>>>>>
>>>>>>>>>> Every halt decider must report on the actual behavior of its
>>>>>>>>>> actual
>>>>>>>>>> input. The notion of a UTM establishes that H is correct to
>>>>>>>>>> base its
>>>>>>>>>> halt status decision on a finite number of steps of D correctly
>>>>>>>>>> simulated by H.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> The notion of a UTM guarantees that when N steps of D are
>>>>>>>>> correctly
>>>>>>>>> simulated by H that this <is> the actual behavior that D
>>>>>>>>> specifies to H.
>>>>>>>>
>>>>>>>> The notion of a UTM is entirely irrelevant since your H and D
>>>>>>>> aren't formulated in terms of Turing Machines in the first
>>>>>>>> place. No where does your code involve a TM, let alone a UTM.
>>>>>>>>
>>>>>>>> The notion of a UTM is simply that it is possible to construct a
>>>>>>>> single TM which can mimic the behaviour of all other TMs. It
>>>>>>>> says nothing whatsoever about making *decisions* about the
>>>>>>>> properties of those TMs.
>>>>>>>>
>>>>>>>> André
>>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> It says more than that. It says that the correct simulation of a
>>>>>>> machine
>>>>>>> description does provide the underlying behavior specified by this
>>>>>>> machine description.
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>
>>>>>>> When embedded_H is a simulating halt decider and
>>>>>>>
>>>>>>> Ĥ is applied to ⟨Ĥ⟩
>>>>>>> (q0) The input ⟨Ĥ⟩ is copied then transitions to embedded_H
>>>>>>> embedded_H is applied to ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy)
>>>>>>> which simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ which begins at its own (q0)
>>>>>>> to repeat the process. (never reaching the simulated ⟨Ĥ.qn⟩ and
>>>>>>> halting).
>>>>>>
>>>>>> Since there is no mention of a UTM anywhere in the above, how can
>>>>>> you claim that the 'notion of a UTM' makes any claims whatsoever
>>>>>> about the above?!?
>>>>>>
>>>>>>> The notion of a UTM guarantees that when N steps of ⟨Ĥ⟩ are
>>>>>>> correctly
>>>>>>> simulated by embedded_H that this <is> the actual behavior that ⟨Ĥ⟩
>>>>>>> specifies to embedded_H.
>>>>>>
>>>>>> Non sequitur. embedded_H is not a UTM.
>>>>>
>>>>> That it is more than a UTM does not negate its UTM properties.
>>>>
>>>> It is not a UTM at all.
>>>>
>>>
>>> A simulating halt decider starts with a UTM and then augments it with
>>> additional features.
>>
>> It doesn't "augment" it. It *changes* it. When given a non-halting
>> computation as its input, a UTM will run forever.
>
> It does not change the steps being simulated thus when N steps are
> correctly simulated by embedded_H this does provide the actual behavior
> of the actual input for these N steps.

But not to the end.

>
> When you and I can see that these N steps provide enough information to
> determine that ⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly
> reach its own simulated final state of ⟨Ĥ.qn⟩ this conclusively proves
> that ⟨Ĥ⟩ presents non-halting behavior to embedded_H.

Nope,.

Remeber, it doesn't matter what H's simulation shows, since it isn't
actually a UTM, what matter is the actual behavior of the machine.

DEFININTION, you know.

How CAN can your non-halting answer be the "correct" ansser, since the
machine being simulated HALTS!!!

You are just so stupid that you think that a machine that halts can
somehow also not halt, and that correct answer can be incorrect and
incorrect answers be correct.

That just proves you are an IDIOT.

Your analysis FAILS becuase it is just based on LIES, but that is all
you know about so your logic doesn't see the problem.

You are going to be stuck with your lies forever, and it seems it will
be impossible for you to actually know what it truth, until it will be
too late.

>
>
>> A simulating halt decider (were such a thing possible) on the other
>> hand, would reject this input and then HALT. This is entirely
>> different from what a UTM does.
>>
>> You can state that there is a *relationship* between your 'simulating
>> halt decider' and a UTM in that the SHD uses similar methods as a UTM
>> to (partially) simulate its input, but that doesn't mean you can
>> legitimately say an SHD *is* a UTM -- it is not (and of course since
>> your H and D are not even turing machines, it makes no sense to talk
>> about UTMs at all).
>>
>> André
>>
>
>

On 4/8/2023 7:53 PM, André G. Isaak wrote:
> On 2023-04-08 17:47, olcott wrote:
>> On 4/8/2023 6:37 PM, André G. Isaak wrote:
>>> On 2023-04-08 17:26, olcott wrote:
>>>> On 4/8/2023 6:09 PM, André G. Isaak wrote:
>>>>> On 2023-04-08 17:00, olcott wrote:
>>>>>> On 4/8/2023 4:39 PM, André G. Isaak wrote:
>>>>>>> On 2023-04-08 15:14, olcott wrote:
>>>>>>>> On 4/8/2023 3:43 PM, olcott wrote:
>>>>>>>>> On 4/8/2023 3:22 PM, André G. Isaak wrote:
>>>>>>>>>> On 2023-04-08 14:10, Ben Bacarisse wrote:
>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 4/7/23 8:37 PM, olcott wrote:
>>>>>>>>>>>
>>>>>>>>>>>>> A masters degree in EE is probably not nearly as much CS as
>>>>>>>>>>>>> a BSBS in CS.
>>>>>>>>>>>>
>>>>>>>>>>>> You think so? Rmmember, my Masters was in Electrical
>>>>>>>>>>>> Engineering and
>>>>>>>>>>>> Computer Science, so I did get a lot of CS material too.
>>>>>>>>>>>
>>>>>>>>>>> Is PO saying he has a double BS degree?  You couldn't make it
>>>>>>>>>>> up!
>>>>>>>>>>
>>>>>>>>>> I think he means BS in Bullshit.
>>>>>>>>>>
>>>>>>>>>> André
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> 01 int D(int (*x)())
>>>>>>>>> 02 {
>>>>>>>>> 03  int Halt_Status = H(x, x);
>>>>>>>>> 04  if (Halt_Status)
>>>>>>>>> 05    HERE: goto HERE;
>>>>>>>>> 06  return Halt_Status;
>>>>>>>>> 07 }
>>>>>>>>> 08
>>>>>>>>> 09 void main()
>>>>>>>>> 10 {
>>>>>>>>> 11  H(D,D);
>>>>>>>>> 12 }
>>>>>>>>>
>>>>>>>>> Every halt decider must report on the actual behavior of its
>>>>>>>>> actual
>>>>>>>>> input. The notion of a UTM establishes that H is correct to
>>>>>>>>> base its
>>>>>>>>> halt status decision on a finite number of steps of D correctly
>>>>>>>>> simulated by H.
>>>>>>>>>
>>>>>>>>
>>>>>>>> The notion of a UTM guarantees that when N steps of D are correctly
>>>>>>>> simulated by H that this <is> the actual behavior that D
>>>>>>>> specifies to H.
>>>>>>>
>>>>>>> The notion of a UTM is entirely irrelevant since your H and D
>>>>>>> aren't formulated in terms of Turing Machines in the first place.
>>>>>>> No where does your code involve a TM, let alone a UTM.
>>>>>>>
>>>>>>> The notion of a UTM is simply that it is possible to construct a
>>>>>>> single TM which can mimic the behaviour of all other TMs. It says
>>>>>>> nothing whatsoever about making *decisions* about the properties
>>>>>>> of those TMs.
>>>>>>>
>>>>>>> André
>>>>>>>
>>>>>>
>>>>>>
>>>>>> It says more than that. It says that the correct simulation of a
>>>>>> machine
>>>>>> description does provide the underlying behavior specified by this
>>>>>> machine description.
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> When embedded_H is a simulating halt decider and
>>>>>>
>>>>>> Ĥ is applied to ⟨Ĥ⟩
>>>>>> (q0) The input ⟨Ĥ⟩ is copied then transitions to embedded_H
>>>>>> embedded_H is applied to ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy)
>>>>>> which simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ which begins at its own (q0) to
>>>>>> repeat the process. (never reaching the simulated ⟨Ĥ.qn⟩ and
>>>>>> halting).
>>>>>
>>>>> Since there is no mention of a UTM anywhere in the above, how can
>>>>> you claim that the 'notion of a UTM' makes any claims whatsoever
>>>>> about the above?!?
>>>>>
>>>>>> The notion of a UTM guarantees that when N steps of ⟨Ĥ⟩ are correctly
>>>>>> simulated by embedded_H that this <is> the actual behavior that ⟨Ĥ⟩
>>>>>> specifies to embedded_H.
>>>>>
>>>>> Non sequitur. embedded_H is not a UTM.
>>>>
>>>> That it is more than a UTM does not negate its UTM properties.
>>>
>>> It is not a UTM at all.
>>>
>>
>> A simulating halt decider starts with a UTM and then augments it with
>> additional features.
>
> It doesn't "augment" it. It *changes* it. When given a non-halting
> computation as its input, a UTM will run forever.

It does not change the steps being simulated thus when N steps are
correctly simulated by embedded_H this does provide the actual behavior
of the actual input for these N steps.

When you and I can see that these N steps provide enough information to
determine that ⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly
reach its own simulated final state of ⟨Ĥ.qn⟩ this conclusively proves
that ⟨Ĥ⟩ presents non-halting behavior to embedded_H.

> A simulating halt
> decider (were such a thing possible) on the other hand, would reject
> this input and then HALT. This is entirely different from what a UTM does.
>
> You can state that there is a *relationship* between your 'simulating
> halt decider' and a UTM in that the SHD uses similar methods as a UTM to
> (partially) simulate its input, but that doesn't mean you can
> legitimately say an SHD *is* a UTM -- it is not (and of course since
> your H and D are not even turing machines, it makes no sense to talk
> about UTMs at all).
>
> André
>

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

On 4/10/23 12:23 PM, olcott wrote:

> It does not change the steps being simulated thus when N steps are
> correctly simulated by embedded_H this does provide the actual behavior
> of the actual input for these N steps.

But N Steps correctly simulated doesn't tell you what a complete and
correct simulation does.
>
> When you and I can see that these N steps provide enough information to
> determine that ⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly
> reach its own simulated final state of ⟨Ĥ.qn⟩ this conclusively proves
> that ⟨Ĥ⟩ presents non-halting behavior to embedded_H.
>

But it DOESN'T, and it CAN'T because H's simulation doesn't reach the
requirements of a actual UTM, so the fact that H can't reach a final
step is IRRELEVENT.

In fact, H DOESN'T "Correctly Simulate" its input, as it doesn't
correctly simulate the CALL instsrruction which is the last instruction
seen.

IT is shown that a call to H(P,P) will eventually return 0 (since that
is what it does) and thus H is INCORRECT in its "Simulation" of the
input, and thus gets the wrong answer.

Since the ACTUAL question put to ANY Halt Decider (SImulating or
otherwise) is does the machine/input represented by the input Halt as an
actual machine, and even you admit that this D(D) Will halt, the ONLY
corrrect answer for H(D,D) is Halting, and you are just shown to be a
pathological liar to try to insist that a wrong answer is right, and
that you arguement is based on LIES AND FALSEHOODS.

Your "Correct SImulation by H" criteria is shown to be a strawman, and
actual a fantasy, since no H that gives an answer ever actually meets
the requriements, even though you LIE about it.

On 4/8/2023 7:53 PM, André G. Isaak wrote:
> On 2023-04-08 17:47, olcott wrote:
>> On 4/8/2023 6:37 PM, André G. Isaak wrote:
>>> On 2023-04-08 17:26, olcott wrote:
>>>> On 4/8/2023 6:09 PM, André G. Isaak wrote:
>>>>> On 2023-04-08 17:00, olcott wrote:
>>>>>> On 4/8/2023 4:39 PM, André G. Isaak wrote:
>>>>>>> On 2023-04-08 15:14, olcott wrote:
>>>>>>>> On 4/8/2023 3:43 PM, olcott wrote:
>>>>>>>>> On 4/8/2023 3:22 PM, André G. Isaak wrote:
>>>>>>>>>> On 2023-04-08 14:10, Ben Bacarisse wrote:
>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 4/7/23 8:37 PM, olcott wrote:
>>>>>>>>>>>
>>>>>>>>>>>>> A masters degree in EE is probably not nearly as much CS as
>>>>>>>>>>>>> a BSBS in CS.
>>>>>>>>>>>>
>>>>>>>>>>>> You think so? Rmmember, my Masters was in Electrical
>>>>>>>>>>>> Engineering and
>>>>>>>>>>>> Computer Science, so I did get a lot of CS material too.
>>>>>>>>>>>
>>>>>>>>>>> Is PO saying he has a double BS degree?  You couldn't make it
>>>>>>>>>>> up!
>>>>>>>>>>
>>>>>>>>>> I think he means BS in Bullshit.
>>>>>>>>>>
>>>>>>>>>> André
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> 01 int D(int (*x)())
>>>>>>>>> 02 {
>>>>>>>>> 03  int Halt_Status = H(x, x);
>>>>>>>>> 04  if (Halt_Status)
>>>>>>>>> 05    HERE: goto HERE;
>>>>>>>>> 06  return Halt_Status;
>>>>>>>>> 07 }
>>>>>>>>> 08
>>>>>>>>> 09 void main()
>>>>>>>>> 10 {
>>>>>>>>> 11  H(D,D);
>>>>>>>>> 12 }
>>>>>>>>>
>>>>>>>>> Every halt decider must report on the actual behavior of its
>>>>>>>>> actual
>>>>>>>>> input. The notion of a UTM establishes that H is correct to
>>>>>>>>> base its
>>>>>>>>> halt status decision on a finite number of steps of D correctly
>>>>>>>>> simulated by H.
>>>>>>>>>
>>>>>>>>
>>>>>>>> The notion of a UTM guarantees that when N steps of D are correctly
>>>>>>>> simulated by H that this <is> the actual behavior that D
>>>>>>>> specifies to H.
>>>>>>>
>>>>>>> The notion of a UTM is entirely irrelevant since your H and D
>>>>>>> aren't formulated in terms of Turing Machines in the first place.
>>>>>>> No where does your code involve a TM, let alone a UTM.
>>>>>>>
>>>>>>> The notion of a UTM is simply that it is possible to construct a
>>>>>>> single TM which can mimic the behaviour of all other TMs. It says
>>>>>>> nothing whatsoever about making *decisions* about the properties
>>>>>>> of those TMs.
>>>>>>>
>>>>>>> André
>>>>>>>
>>>>>>
>>>>>>
>>>>>> It says more than that. It says that the correct simulation of a
>>>>>> machine
>>>>>> description does provide the underlying behavior specified by this
>>>>>> machine description.
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> When embedded_H is a simulating halt decider and
>>>>>>
>>>>>> Ĥ is applied to ⟨Ĥ⟩
>>>>>> (q0) The input ⟨Ĥ⟩ is copied then transitions to embedded_H
>>>>>> embedded_H is applied to ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy)
>>>>>> which simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ which begins at its own (q0) to
>>>>>> repeat the process. (never reaching the simulated ⟨Ĥ.qn⟩ and
>>>>>> halting).
>>>>>
>>>>> Since there is no mention of a UTM anywhere in the above, how can
>>>>> you claim that the 'notion of a UTM' makes any claims whatsoever
>>>>> about the above?!?
>>>>>
>>>>>> The notion of a UTM guarantees that when N steps of ⟨Ĥ⟩ are correctly
>>>>>> simulated by embedded_H that this <is> the actual behavior that ⟨Ĥ⟩
>>>>>> specifies to embedded_H.
>>>>>
>>>>> Non sequitur. embedded_H is not a UTM.
>>>>
>>>> That it is more than a UTM does not negate its UTM properties.
>>>
>>> It is not a UTM at all.
>>>
>>
>> A simulating halt decider starts with a UTM and then augments it with
>> additional features.
>
> It doesn't "augment" it. It *changes* it. When given a non-halting
> computation as its input, a UTM will run forever.

It does not change the steps being simulated thus when N steps are
correctly simulated by embedded_H this does provide the actual behavior
of the actual input for these N steps.

When you and I can see that these N steps provide enough information to
determine that ⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly
reach its own simulated final state of ⟨Ĥ.qn⟩ in any finite number of
steps of correct simulation this conclusively proves that ⟨Ĥ⟩ presents
non-halting behavior to embedded_H.

> A simulating halt
> decider (were such a thing possible) on the other hand, would reject
> this input and then HALT. This is entirely different from what a UTM does.
>
> You can state that there is a *relationship* between your 'simulating
> halt decider' and a UTM in that the SHD uses similar methods as a UTM to
> (partially) simulate its input, but that doesn't mean you can
> legitimately say an SHD *is* a UTM -- it is not (and of course since
> your H and D are not even turing machines, it makes no sense to talk
> about UTMs at all).
>
> André
>

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