On Tuesday, August 9, 2022 at 8:32:07 PM UTC-4, olcott wrote:
> On 8/9/2022 6:43 PM, dklei...@gmail.com wrote:
> > On Monday, August 8, 2022 at 12:52:27 PM UTC-7, olcott wrote:
> >> On 8/8/2022 2:36 PM, dklei...@gmail.com wrote:
> >>> On Sunday, August 7, 2022 at 2:12:59 PM UTC-7, olcott wrote:
> >>>>
> >>>> WE MUST GO THOUGH MY PROOF POINT-BY-POINT AND STEP-BY-STEP.
> >>>> EVERYONE LEAPS AHEAD PREVENTING CLOSURE ON EVEN A SINGLE POINT.
> >>>>
> >>> That would something devoutly to be desired. It has never been attempted.
> >>> First off, what are we trying to prove?
> >
> > You haven't answered that question. What are you trying to prove?
> >
> > Perhaps your goal is:
> >>
> >> when H(P,P) correctly matches this
> >> non-halting behavior pattern it can abort the simulation of its
> >> input and reject it as non-halting.
> >>
> > But we can entertain such a goal only after we define what, in
> > this statement, is meant by:
> > H(P,P)
> > match
> > non-halting behavior pattern
> > abort
> > simulation
> > input
> > reject
> > non-halting
> And we can't begin to answer that until after we have
> "entertain"
> "such"
> "a"
> "goal"
> "only"
> "after"
> "we"
> "define"
> "what"
> "in"
> "this"
> "statement"
> "is"
> "meant"
> and
> "by"
> defined.
>
> This goes on recursively until one of us dies thus totally avoiding the
> point.
>
> In computability theory, the halting problem is the problem
> of determining, from a description of an arbitrary computer
> program and an input,

I.E. X and Y

> whether the program will finish running,
> or continue to run forever.

In other words:

H(X,Y)==1 if and only if X(Y) halts, and
H(X,Y)==0 if and only if X(Y) does not halt

> Alan Turing proved in 1936 that a
> general algorithm to solve the halting problem for all possible
> program-input pairs cannot exist.
>
> For any program H that might determine if programs halt, a
> "pathological" program P, called with some input, can pass
> its own source and its input to H and then specifically do the
> opposite of what H predicts P will do.
> *No H can exist that handles this case*
> https://en.wikipedia.org/wiki/Halting_problem
> typedef void (*ptr)();
> int H(ptr p, ptr i); // simulating halt decider
>
> void P(ptr x)
> {
> int Halt_Status = H(x, x);
> if (Halt_Status)
> HERE: goto HERE;
> return;
> }
>
> int main()
> {
> Output("Input_Halts = ", H(P, P));
> }
> I created a C function based on an x86 emulator (look it up) that
> correctly determines the halt status of the above HP "impossible" input.

So your H can perform the following mapping?

H(X,Y)==1 if and only if X(Y) halts, and
H(X,Y)==0 if and only if X(Y) does not halt

> >>
> >>> Second off, how does the mapping
> >>> to C work?
> >
> > And you made no attempt to answer this. What I asking
> > for is: Given a C statement what Turing Machine process
> > does it map to and given a Turing Machine statement
> > what C statement does it map to.
> >
> > Incidentally I think that what I imagine is your goal is
> > trivially true. But expounding it takes a decent expansion
> > of Turing Machine facts as foundation. I have no idea
> > whether Linz or one of the others provides such a goal.
> > You haven't.

On Tuesday, August 9, 2022 at 5:32:07 PM UTC-7, olcott wrote:
> On 8/9/2022 6:43 PM, dklei...@gmail.com wrote:
> > On Monday, August 8, 2022 at 12:52:27 PM UTC-7, olcott wrote:
> >> On 8/8/2022 2:36 PM, dklei...@gmail.com wrote:
> >>> On Sunday, August 7, 2022 at 2:12:59 PM UTC-7, olcott wrote:
> >>>>
> >>>> WE MUST GO THOUGH MY PROOF POINT-BY-POINT AND STEP-BY-STEP.
> >>>> EVERYONE LEAPS AHEAD PREVENTING CLOSURE ON EVEN A SINGLE POINT.
> >>>>
> >>> That would something devoutly to be desired. It has never been attempted.
> >>> First off, what are we trying to prove?
> >
> > You haven't answered that question. What are you trying to prove?
> >
> > Perhaps your goal is:
> >>
> >> when H(P,P) correctly matches this
> >> non-halting behavior pattern it can abort the simulation of its
> >> input and reject it as non-halting.
> >>
> > But we can entertain such a goal only after we define what, in
> > this statement, is meant by:
> > H(P,P)
> > match
> > non-halting behavior pattern
> > abort
> > simulation
> > input
> > reject
> > non-halting
> And we can't begin to answer that until after we have
> "entertain"
> "such"
> "a"
> "goal"
> "only"
> "after"
> "we"
> "define"
> "what"
> "in"
> "this"
> "statement"
> "is"
> "meant"
> and
> "by"
> defined.
>
> This goes on recursively until one of us dies thus totally avoiding the
> point.

These are terms of the meta-language. The words I listed are technical
meaning they have no meanings in the meta-language and must be
suppled with definitions. This is standard everywhere in human
communication.

By the way no recursion is involved - your list is not defined the
same way as they themselves enter into definition.
>
> In computability theory, the halting problem is the problem
> of determining, from a description of an arbitrary computer
> program and an input, whether the program will finish running,
> or continue to run forever.
>
In ordinary use "the halting theorem" is a concept of Turing
Machine theory. The Turing Machine was described by Turing
and exists in its own little Turing world. It can be emulated or
encoded in mathematical/logical terms. We call the process
defined in the machine "run" or "execute" but we have no
concept of what those mean other than that supplied by
emulation. One of the attributes of an emulation is a set
(possibly empty) of final states. An emulation "halts" if it
reaches a final state. The halting question is whether a
particular emulation halts.

We can encode the code, data and control (states) in a
form compatible with Turing Machine data. But there
is no machine whose emulation halts and indicates
whether the encoded code, data and control when
emulated will halt.

On 8/9/2022 10:18 PM, dklei...@gmail.com wrote:
> On Tuesday, August 9, 2022 at 5:32:07 PM UTC-7, olcott wrote:
>> On 8/9/2022 6:43 PM, dklei...@gmail.com wrote:
>>> On Monday, August 8, 2022 at 12:52:27 PM UTC-7, olcott wrote:
>>>> On 8/8/2022 2:36 PM, dklei...@gmail.com wrote:
>>>>> On Sunday, August 7, 2022 at 2:12:59 PM UTC-7, olcott wrote:
>>>>>>
>>>>>> WE MUST GO THOUGH MY PROOF POINT-BY-POINT AND STEP-BY-STEP.
>>>>>> EVERYONE LEAPS AHEAD PREVENTING CLOSURE ON EVEN A SINGLE POINT.
>>>>>>
>>>>> That would something devoutly to be desired. It has never been attempted.
>>>>> First off, what are we trying to prove?
>>>
>>> You haven't answered that question. What are you trying to prove?
>>>
>>> Perhaps your goal is:
>>>>
>>>> when H(P,P) correctly matches this
>>>> non-halting behavior pattern it can abort the simulation of its
>>>> input and reject it as non-halting.
>>>>
>>> But we can entertain such a goal only after we define what, in
>>> this statement, is meant by:
>>> H(P,P)
>>> match
>>> non-halting behavior pattern
>>> abort
>>> simulation
>>> input
>>> reject
>>> non-halting
>> And we can't begin to answer that until after we have
>> "entertain"
>> "such"
>> "a"
>> "goal"
>> "only"
>> "after"
>> "we"
>> "define"
>> "what"
>> "in"
>> "this"
>> "statement"
>> "is"
>> "meant"
>> and
>> "by"
>> defined.
>>
>> This goes on recursively until one of us dies thus totally avoiding the
>> point.
>
> These are terms of the meta-language. The words I listed are technical
> meaning they have no meanings in the meta-language and must be
> suppled with definitions. This is standard everywhere in human
> communication.
>
> By the way no recursion is involved - your list is not defined the
> same way as they themselves enter into definition.
>>
>> In computability theory, the halting problem is the problem
>> of determining, from a description of an arbitrary computer
>> program and an input, whether the program will finish running,
>> or continue to run forever.
>>
> In ordinary use "the halting theorem" is a concept of Turing
> Machine theory. The Turing Machine was described by Turing
> and exists in its own little Turing world. It can be emulated or
> encoded in mathematical/logical terms. We call the process
> defined in the machine "run" or "execute" but we have no
> concept of what those mean other than that supplied by
> emulation. One of the attributes of an emulation is a set
> (possibly empty) of final states. An emulation "halts" if it
> reaches a final state. The halting question is whether a
> particular emulation halts.
>
> We can encode the code, data and control (states) in a
> form compatible with Turing Machine data. But there
> is no machine whose emulation halts and indicates
> whether the encoded code, data and control when
> emulated will halt.

So you asked for concretely what I mean, and then when I provide this
concretely you simply ignore it.

typedef void (*ptr)();
int H(ptr p, ptr i); // simulating halt decider

void P(ptr x)
{ int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return;
}

int main()
{ Output("Input_Halts = ", H(P, P));
}

--
Copyright 2022 Pete Olcott

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

On 8/9/22 11:30 PM, olcott wrote:
> On 8/9/2022 10:18 PM, dklei...@gmail.com wrote:
>> On Tuesday, August 9, 2022 at 5:32:07 PM UTC-7, olcott wrote:
>>> On 8/9/2022 6:43 PM, dklei...@gmail.com wrote:
>>>> On Monday, August 8, 2022 at 12:52:27 PM UTC-7, olcott wrote:
>>>>> On 8/8/2022 2:36 PM, dklei...@gmail.com wrote:
>>>>>> On Sunday, August 7, 2022 at 2:12:59 PM UTC-7, olcott wrote:
>>>>>>>
>>>>>>> WE MUST GO THOUGH MY PROOF POINT-BY-POINT AND STEP-BY-STEP.
>>>>>>> EVERYONE LEAPS AHEAD PREVENTING CLOSURE ON EVEN A SINGLE POINT.
>>>>>>>
>>>>>> That would something devoutly to be desired. It has never been
>>>>>> attempted.
>>>>>> First off, what are we trying to prove?
>>>>
>>>> You haven't answered that question. What are you trying to prove?
>>>>
>>>> Perhaps your goal is:
>>>>>
>>>>> when H(P,P) correctly matches this
>>>>> non-halting behavior pattern it can abort the simulation of its
>>>>> input and reject it as non-halting.
>>>>>
>>>> But we can entertain such a goal only after we define what, in
>>>> this statement, is meant by:
>>>> H(P,P)
>>>> match
>>>> non-halting behavior pattern
>>>> abort
>>>> simulation
>>>> input
>>>> reject
>>>> non-halting
>>> And we can't begin to answer that until after we have
>>> "entertain"
>>> "such"
>>> "a"
>>> "goal"
>>> "only"
>>> "after"
>>> "we"
>>> "define"
>>> "what"
>>> "in"
>>> "this"
>>> "statement"
>>> "is"
>>> "meant"
>>> and
>>> "by"
>>> defined.
>>>
>>> This goes on recursively until one of us dies thus totally avoiding the
>>> point.
>>
>> These are terms of the meta-language. The words I listed are technical
>> meaning they have no meanings in the meta-language and must be
>> suppled with definitions. This is standard everywhere in human
>> communication.
>>
>> By the way no recursion is involved - your list is not defined the
>> same way as they themselves enter into definition.
>>>
>>> In computability theory, the halting problem is the problem
>>> of determining, from a description of an arbitrary computer
>>> program and an input, whether the program will finish running,
>>> or continue to run forever.
>>>
>> In ordinary use "the halting theorem" is a concept of Turing
>> Machine theory. The Turing Machine was described by Turing
>> and exists in its own little Turing world. It can be emulated or
>> encoded in mathematical/logical terms. We call the process
>> defined in the machine "run" or "execute" but we have no
>> concept of what those mean other than that supplied by
>> emulation. One of the attributes of an emulation is a set
>> (possibly empty) of final states. An emulation "halts" if it
>> reaches a final state. The halting question is whether a
>> particular emulation halts.
>>
>> We can encode the code, data and control (states) in a
>> form compatible with Turing Machine data. But there
>> is no machine whose emulation halts and indicates
>> whether the encoded code, data and control when
>> emulated will halt.
>
> So you asked for concretely what I mean, and then when I provide this
> concretely you simply ignore it.
>
> typedef void (*ptr)();
> int H(ptr p, ptr i); // simulating halt decider
>
> void P(ptr x)
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return;
> }
>
> int main()
> {
>   Output("Input_Halts = ", H(P, P));
> }
>
>

So, how does that show you are right?

By the definition:

H(P,P) must return 1 if P(P) Halts in a finite number of steps, and ]
H(P,P) must return 0 if P(P) never Halts in an unbounded number of steps.

You NEVER bother to TEST you answers, so you can't "prove" your are right.

Change Main to be:

int main()
{ Output("Input_Halts = ", H(P,P));
P(P);
Output(" But P(P) Halts");
}

Which will print:

Input_Halts = 0 But P(P) Halts.

Thus H was WRONG by the definition of a Halt Decider.

On Tuesday, August 9, 2022 at 8:30:49 PM UTC-7, olcott wrote:
>
> So you asked for concretely what I mean, and then when I provide this
> concretely you simply ignore it.
>
> typedef void (*ptr)();
> int H(ptr p, ptr i); // simulating halt decider
>
> void P(ptr x)
> {
> int Halt_Status = H(x, x);
> if (Halt_Status)
> HERE: goto HERE;
> return;
> }
>
> int main()
> {
> Output("Input_Halts = ", H(P, P));
> }
>
If that is what you mean of course I ignored it

It just a fragment of trivial C program. Meaning what?

On 8/11/2022 11:57 PM, dklei...@gmail.com wrote:
> On Tuesday, August 9, 2022 at 8:30:49 PM UTC-7, olcott wrote:
>>
>> So you asked for concretely what I mean, and then when I provide this
>> concretely you simply ignore it.
>>
>> typedef void (*ptr)();
>> int H(ptr p, ptr i); // simulating halt decider
>>
>> void P(ptr x)
>> {
>> int Halt_Status = H(x, x);
>> if (Halt_Status)
>> HERE: goto HERE;
>> return;
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", H(P, P));
>> }
>>
> If that is what you mean of course I ignored it
>
> It just a fragment of trivial C program. Meaning what?

If you don't immediately recognize that as the halting problem's
"impossible" input, then you hardly know the HP much at all.

--
Copyright 2022 Pete Olcott

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

On Thursday, August 11, 2022 at 10:28:31 PM UTC-7, olcott wrote:
> On 8/11/2022 11:57 PM, dklei...@gmail.com wrote:
> > On Tuesday, August 9, 2022 at 8:30:49 PM UTC-7, olcott wrote:
> >>
> >> So you asked for concretely what I mean, and then when I provide this
> >> concretely you simply ignore it.
> >>
> >> typedef void (*ptr)();
> >> int H(ptr p, ptr i); // simulating halt decider
> >>
> >> void P(ptr x)
> >> {
> >> int Halt_Status = H(x, x);
> >> if (Halt_Status)
> >> HERE: goto HERE;
> >> return;
> >> }
> >>
> >> int main()
> >> {
> >> Output("Input_Halts = ", H(P, P));
> >> }
> >>
> > If that is what you mean of course I ignored it
> >
> > It just a fragment of trivial C program. Meaning what?
>
> If you don't immediately recognize that as the halting problem's
> "impossible" input, then you hardly know the HP much at all.
>
Without any knowledge of what H does your code is meaningless.

For example H(X,Y) {return 0};

On 8/12/2022 3:22 PM, dklei...@gmail.com wrote:
> On Thursday, August 11, 2022 at 10:28:31 PM UTC-7, olcott wrote:
>> On 8/11/2022 11:57 PM, dklei...@gmail.com wrote:
>>> On Tuesday, August 9, 2022 at 8:30:49 PM UTC-7, olcott wrote:
>>>>
>>>> So you asked for concretely what I mean, and then when I provide this
>>>> concretely you simply ignore it.
>>>>
>>>> typedef void (*ptr)();
>>>> int H(ptr p, ptr i); // simulating halt decider
>>>>
>>>> void P(ptr x)
>>>> {
>>>> int Halt_Status = H(x, x);
>>>> if (Halt_Status)
>>>> HERE: goto HERE;
>>>> return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> Output("Input_Halts = ", H(P, P));
>>>> }
>>>>
>>> If that is what you mean of course I ignored it
>>>
>>> It just a fragment of trivial C program. Meaning what?
>>
>> If you don't immediately recognize that as the halting problem's
>> "impossible" input, then you hardly know the HP much at all.
>>
> Without any knowledge of what H does your code is meaningless.
>
> For example H(X,Y) {return 0};

Of course everyone knows that a simulating halt decider only dances the
jig and nothing else because the word "simulate" only has the one
meaning of {dancing the jig}.

I have explained all of these things 10,000 times. Please read my paper.

*Halting problem proofs refuted on the basis of software engineering* ?
https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering

--
Copyright 2022 Pete Olcott

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

On Friday, August 12, 2022 at 1:41:22 PM UTC-7, olcott wrote:
> On 8/12/2022 3:22 PM, dklei...@gmail.com wrote:
> > On Thursday, August 11, 2022 at 10:28:31 PM UTC-7, olcott wrote:
> >> On 8/11/2022 11:57 PM, dklei...@gmail.com wrote:
> >>> On Tuesday, August 9, 2022 at 8:30:49 PM UTC-7, olcott wrote:
> >>>>
> >>>> So you asked for concretely what I mean, and then when I provide this
> >>>> concretely you simply ignore it.
> >>>>
> >>>> typedef void (*ptr)();
> >>>> int H(ptr p, ptr i); // simulating halt decider
> >>>>
> >>>> void P(ptr x)
> >>>> {
> >>>> int Halt_Status = H(x, x);
> >>>> if (Halt_Status)
> >>>> HERE: goto HERE;
> >>>> return;
> >>>> }
> >>>>
> >>>> int main()
> >>>> {
> >>>> Output("Input_Halts = ", H(P, P));
> >>>> }
> >>>>
> >>> If that is what you mean of course I ignored it
> >>>
> >>> It just a fragment of trivial C program. Meaning what?
> >>
> >> If you don't immediately recognize that as the halting problem's
> >> "impossible" input, then you hardly know the HP much at all.
> >>
> > Without any knowledge of what H does your code is meaningless.
> >
> > For example H(X,Y) {return 0};
> Of course everyone knows that a simulating halt decider only dances the
> jig and nothing else because the word "simulate" only has the one
> meaning of {dancing the jig}.
>
> I have explained all of these things 10,000 times. Please read my paper.
>
> *Halting problem proofs refuted on the basis of software engineering* ?
> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
>
What we have here is failure to communicate. You haven't, in your code,
even made a clear comment that H is a simulating halt decider much
less what that phrase means.