Google Groups no longer supports new Usenet posts or subscriptions. Historical content remains viewable.

Dismiss

15 views

Skip to first unread message

Aug 4, 2023, 6:44:20 PM8/4/23

to

The execution trace of D correctly simulated by H proves that D cannot

possibly terminate normally. When H is required to report on the actual

behavior of its input it must reject D as non-halting.

This same requirement also forbids H to report on the behavior of the

non-input D(D) directly executed in main(). These same ideas are also

applied to the Peter Linz Turing Machine based halting problem proof.

"A decision problem is a yes-or-no question on an infinite set of

inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition

Can D correctly simulated by H terminate normally?

The x86utm operating system based on an open source x86 emulator. This

system enables one C function to execute another C function in debug

step mode. When H simulates D it creates a separate process context for

D with its own memory, stack and virtual registers. H is able to

simulate D simulating itself, thus the only limit to recursive

simulations is RAM.

// The following is written in C

//

01 typedef int (*ptr)(); // pointer to int function

02 int H(ptr x, ptr y) // uses x86 emulator to simulate its input

03

04 int D(ptr x)

05 {

06 int Halt_Status = H(x, x);

07 if (Halt_Status)

08 HERE: goto HERE;

09 return Halt_Status;

10 }

11

12 void main()

13 {

14 H(D,D);

15 }

Execution Trace

Line 14: main() invokes H(D,D);

keeps repeating (unless aborted)

Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)

Simulation invariant:

D correctly simulated by H cannot possibly reach past its own line 06.

H correctly determines that D correctly simulated by H cannot possibly

terminate normally on the basis that H recognizes a dynamic behavior

pattern equivalent to infinite recursion.

H outputs: "H: Infinitely Recursive Simulation Detected Simulation

Stopped" indicating that D has defined a pathological (see above)

relationship to H.

*Termination Analyzer H is Not Fooled by Pathological Input D*

https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D

--

Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius

hits a target no one else can see." Arthur Schopenhauer

possibly terminate normally. When H is required to report on the actual

behavior of its input it must reject D as non-halting.

This same requirement also forbids H to report on the behavior of the

non-input D(D) directly executed in main(). These same ideas are also

applied to the Peter Linz Turing Machine based halting problem proof.

"A decision problem is a yes-or-no question on an infinite set of

inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition

Can D correctly simulated by H terminate normally?

The x86utm operating system based on an open source x86 emulator. This

system enables one C function to execute another C function in debug

step mode. When H simulates D it creates a separate process context for

D with its own memory, stack and virtual registers. H is able to

simulate D simulating itself, thus the only limit to recursive

simulations is RAM.

// The following is written in C

//

01 typedef int (*ptr)(); // pointer to int function

02 int H(ptr x, ptr y) // uses x86 emulator to simulate its input

03

04 int D(ptr x)

05 {

06 int Halt_Status = H(x, x);

07 if (Halt_Status)

08 HERE: goto HERE;

09 return Halt_Status;

10 }

11

12 void main()

13 {

14 H(D,D);

15 }

Execution Trace

Line 14: main() invokes H(D,D);

keeps repeating (unless aborted)

Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)

Simulation invariant:

D correctly simulated by H cannot possibly reach past its own line 06.

H correctly determines that D correctly simulated by H cannot possibly

terminate normally on the basis that H recognizes a dynamic behavior

pattern equivalent to infinite recursion.

H outputs: "H: Infinitely Recursive Simulation Detected Simulation

Stopped" indicating that D has defined a pathological (see above)

relationship to H.

*Termination Analyzer H is Not Fooled by Pathological Input D*

https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D

--

Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius

hits a target no one else can see." Arthur Schopenhauer

Aug 4, 2023, 10:01:44 PM8/4/23

to

On 8/4/23 6:44 PM, olcott wrote:

> The execution trace of D correctly simulated by H proves that D cannot

> possibly terminate normally. When H is required to report on the actual

> behavior of its input it must reject D as non-halting.

Does H "Correctly Simulate" its input?, and give ann answer?
> The execution trace of D correctly simulated by H proves that D cannot

> possibly terminate normally. When H is required to report on the actual

> behavior of its input it must reject D as non-halting.

HOW?

You H just fails to be a compuation if you try to define that it does

so, as it doesn't always do the same thing for a given input, and you

are thus just admitting to being a LIAR.

>

> This same requirement also forbids H to report on the behavior of the

> non-input D(D) directly executed in main(). These same ideas are also

> applied to the Peter Linz Turing Machine based halting problem proof.

"Halt Decider", as BY DEFINITION, the input to a Halt decider is the

description of the machine that it is to decide about, and that would be

D(D) in this case.

>

> "A decision problem is a yes-or-no question on an infinite set of

> inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition

And for the HALTING PROBLEM, that "yes-or-no question" is based on the

behavior of the computation described by the input to the decider.

>

> Can D correctly simulated by H terminate normally?

admitting that you ar just a pathological liar about what you are doing.

You seem to think you can answer the WRONG question and claim to be right.

> The x86utm operating system based on an open source x86 emulator. This

> system enables one C function to execute another C function in debug

> step mode. When H simulates D it creates a separate process context for

> D with its own memory, stack and virtual registers. H is able to

> simulate D simulating itself, thus the only limit to recursive

> simulations is RAM.

If it doesn't give the answer to the REQUIRED question, it just is wrong.

Remember THE DEFINTION of the Halting Problem is the question can we

design a computation that can answer for ANY possible computation

described to it, it that computation will finish in finite time (number

of steps), so the question to the computation is what is the behavior of

the computation described by its input.

If H(D,D) isn't asking about D(D), what does, of are you just admitting

that you are wrong.

Halting Problem is asking about, so you claim that this CAN'T be what

your H is being asked about just means you are just ADMITTING that you

are LYING about working on the Halting Problem.

Your "Logic" just prove that you are TOTALLY IGNORANT of what you are

claiming to be talking about.

Ultimately, you are just proving the following facts about your self:

1) you are totally ignorant of the actual definition of the problem you

claim to be working on, and just ignore when people correct you, meaning

your errors are not "honest mistakes"

2) you are intentionally decpetive about your claims, using incorrect

definitions of terms for the context that they are being used in.

1) you are just a pathological liar, as you claim things that are

clearly not true. It can't be an "Honest Mistake" as you repeat the

errors when correct.

4) You are showing your idiodicy by the fact that you keep repeating

your errors, thinking that by just repeating them enough you might make

people think they are true. (Which is one of the definitions of a "Big Lie")

5) This also says you match one of the defintions of Insanity.

Aug 5, 2023, 1:59:37 PM8/5/23

to

*Termination Analyzer H is Not Fooled by Pathological Input D*

When the halting problem is construed as requiring a correct yes/no
answer to a contradictory question it cannot be solved. The halting

problem question is only contradictory when a halt decider must divide

arbitrary finite string pairs (including non-inputs) into those that

halt on their input and those that do not. When we exclude non-inputs

then the contradiction is unreachable by D correctly simulated by H thus

has no effect.

The execution trace of D correctly simulated by H proves that this D

cannot possibly terminate normally. When H is required to report on the

actual behavior of its input it must reject D as non-halting. This same

requirement also forbids H to report on the (differing) behavior of the
actual behavior of its input it must reject D as non-halting. This same

non-input D(D) directly executed in main(). These same ideas are also

applied to the Peter Linz Turing Machine based halting problem proof

(shown below).
applied to the Peter Linz Turing Machine based halting problem proof

Line 14: main() invokes H(D,D);

*keeps repeating* (unless aborted)
Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)

*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 06.

H correctly determines that D correctly simulated by H cannot possibly

terminate normally on the basis that H recognizes a dynamic behavior

pattern equivalent to infinite recursion. H returns 0 this basis.
H correctly determines that D correctly simulated by H cannot possibly

terminate normally on the basis that H recognizes a dynamic behavior

Aug 5, 2023, 4:14:48 PM8/5/23

to

factual. The key dishonest rebuttal in the last two years is that D(D)

executed from main() <is> an input parameter to H(D,D).

This lie is promoted because the liars know that deciders only operate

on inputs.

The other key dishonest rebuttal is that the actual correct execution

trace of D correctly simulated by H (shown above) is not the actual

correct execution trace of D correctly simulated by H.

What moron thinks that they can get away with claiming that a thing is

not itself?

Aug 5, 2023, 9:02:58 PM8/5/23

to

meaning of the words you are using.

>

> This lie is promoted because the liars know that deciders only operate

> on inputs.

>

> The other key dishonest rebuttal is that the actual correct execution

> trace of D correctly simulated by H (shown above) is not the actual

> correct execution trace of D correctly simulated by H.

machine, your statement is just a LIE,.

>

> What moron thinks that they can get away with claiming that a thing is

> not itself?

>

>

Remember, CORRECT SIMULATION means match the ACTUAL THING, that is the

machine being simulated.

You just don't undrstand basic English.

Aug 5, 2023, 9:03:12 PM8/5/23

to

The question is NOT "Contradictory" under the conditions required by the

problem, that the input be an actual computaiton.

ALL computation will either Halt or Not.

The only way the proof program isn't an actual computation is if the

claimed decider is not.

So, you are admitting that you whole proof is based on the LIE that your

decider meets the requirements.

YOU FAIL.

Aug 5, 2023, 9:07:50 PM8/5/23

to

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

Remember, the definition of the halt decider is that it decides on the

machine the input *REPRESENTS*

And, if the parameters for H(D,D) don't REPRESENT D(D), then what

computation is it suppose to REPRESENT, and how do you represent the

computaiton D(D).

Since you can't actually answer that question, your arguement is show to

just fall apart.

>

> This lie is promoted because the liars know that deciders only operate

> on inputs.

Or, don't you understand "abstract" thinking.

Aug 11, 2023, 5:29:17 PM8/11/23

to

When it is understood that D correctly simulated by H is the behavior

that H must report on then the halting problem's otherwise impossible

input is correctly determined to be non-halting.

We can know that D correctly simulated by H must have different behavior

than D(D) directly executed in main() because we can see (in its

execution trace shown below) exactly how the pathological relationship

between D and H changes the behavior of D relative to H.

For any program H that might determine whether programs halt, a

"pathological" program D, called with some input, can pass its own

source and its input to H and then specifically do the opposite of what

H predicts D will do. No H can exist that handles this case.

https://en.wikipedia.org/wiki/Halting_problem

"A decision problem is a yes-or-no question on an infinite set of

inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition

has no effect.

Can D correctly simulated by H terminate normally?

The x86utm operating system based on an open source x86 emulator. This

system enables one C function to execute another C function in debug

step mode. When H simulates D it creates a separate process context for

D with its own memory, stack and virtual registers. H is able to

simulate D simulating itself, thus the only limit to recursive

simulations is RAM.

// The following is written in C

//

01 typedef int (*ptr)(); // pointer to int function

02 int H(ptr x, ptr y) // uses x86 emulator to simulate its input

03

04 int D(ptr x)

05 {

06 int Halt_Status = H(x, x);

07 if (Halt_Status)

08 HERE: goto HERE;

09 return Halt_Status;

10 }

11

12 void main()

13 {

14 H(D,D);

15 }

*Execution Trace*

that H must report on then the halting problem's otherwise impossible

input is correctly determined to be non-halting.

We can know that D correctly simulated by H must have different behavior

than D(D) directly executed in main() because we can see (in its

execution trace shown below) exactly how the pathological relationship

between D and H changes the behavior of D relative to H.

For any program H that might determine whether programs halt, a

"pathological" program D, called with some input, can pass its own

source and its input to H and then specifically do the opposite of what

H predicts D will do. No H can exist that handles this case.

https://en.wikipedia.org/wiki/Halting_problem

"A decision problem is a yes-or-no question on an infinite set of

inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition

When the halting problem is construed as requiring a correct yes/no

answer to a contradictory question it cannot be solved. The halting

problem question is only contradictory when a halt decider must divide

arbitrary finite string pairs (including non-inputs) into those that

halt on their input and those that do not. When we exclude non-inputs

then the contradiction is unreachable by D correctly simulated by H thus
answer to a contradictory question it cannot be solved. The halting

problem question is only contradictory when a halt decider must divide

arbitrary finite string pairs (including non-inputs) into those that

halt on their input and those that do not. When we exclude non-inputs

has no effect.

Can D correctly simulated by H terminate normally?

The x86utm operating system based on an open source x86 emulator. This

system enables one C function to execute another C function in debug

step mode. When H simulates D it creates a separate process context for

D with its own memory, stack and virtual registers. H is able to

simulate D simulating itself, thus the only limit to recursive

simulations is RAM.

// The following is written in C

//

01 typedef int (*ptr)(); // pointer to int function

02 int H(ptr x, ptr y) // uses x86 emulator to simulate its input

03

04 int D(ptr x)

05 {

06 int Halt_Status = H(x, x);

07 if (Halt_Status)

08 HERE: goto HERE;

09 return Halt_Status;

10 }

11

12 void main()

13 {

14 H(D,D);

15 }

Line 14: main() invokes H(D,D);

*keeps repeating* (unless aborted)
Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)

*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 06.

Aug 11, 2023, 7:25:22 PM8/11/23

to

On 8/11/23 5:29 PM, olcott wrote:

> When it is understood that D correctly simulated by H is the behavior

> that H must report on then the halting problem's otherwise impossible

> input is correctly determined to be non-halting.

>

Except you are neglecting that THIS H doesn't "Correctly Simulate" its
> When it is understood that D correctly simulated by H is the behavior

> that H must report on then the halting problem's otherwise impossible

> input is correctly determined to be non-halting.

>

input, so that statement is just a LIE.

There is NOTHING impossible about this input, as ANY actual correct

simulator will show that it is halting.

> We can know that D correctly simulated by H must have different behavior

> than D(D) directly executed in main() because we can see (in its

> execution trace shown below) exactly how the pathological relationship

> between D and H changes the behavior of D relative to H.

simulation the results in the exact behavior of the thing being simulated.

Since H is claimed to be a "Halt Decider", the machine "Described" by

its input is exactly "D(D)", so a "Correct Simulaiton" of that

>

> For any program H that might determine whether programs halt, a

> "pathological" program D, called with some input, can pass its own

> source and its input to H and then specifically do the opposite of what

> H predicts D will do. No H can exist that handles this case.

> https://en.wikipedia.org/wiki/Halting_problem

You are just proving that you don't understand the definitions.

>

> "A decision problem is a yes-or-no question on an infinite set of

> inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition

>

> When the halting problem is construed as requiring a correct yes/no

> answer to a contradictory question it cannot be solved. The halting

> problem question is only contradictory when a halt decider must divide

> arbitrary finite string pairs (including non-inputs) into those that

> halt on their input and those that do not. When we exclude non-inputs

> then the contradiction is unreachable by D correctly simulated by H thus

> has no effect.

machine, even this "pathological" one has a definite answer. The

"pathology" doesn't make the answer indererminate, it just makes it that

no decider can give the correct answer for the input specifically

targeted to it, but other deciders have no problem.

>

> Can D correctly simulated by H terminate normally?

the question "Have you stopped lying yet?" (well, have you?)

Now, if you make a DIFFERENT machine "D" off of a DIFFERENT machine "H"

that does actually correct simulate its input until it proves the

answer, then the answer is no, that "D" won't terminate, but it is also

true that the "H" won't answer ans thus fails to be a decider.

Since THIS "H" isn't THAT "H", the question is just irrelevent, and a

logical fallicy to bring up.

You just don't seem to understand the nature of what a program is.

> The x86utm operating system based on an open source x86 emulator. This

> system enables one C function to execute another C function in debug

> step mode. When H simulates D it creates a separate process context for

> D with its own memory, stack and virtual registers. H is able to

> simulate D simulating itself, thus the only limit to recursive

> simulations is RAM.

>

input, since is assumes that a call to H(D,D) will not return, when it

does, since THIS H does abort and return.

Thus, it doesn't actually look at the ACTUAL input given to it, but

presumes H is something different than what it is.

And thus gets the WRONG answer.

> // The following is written in C

> //

> 01 typedef int (*ptr)(); // pointer to int function

> 02 int H(ptr x, ptr y) // uses x86 emulator to simulate its input

> 03

> 04 int D(ptr x)

> 05 {

> 06 int Halt_Status = H(x, x);

> 07 if (Halt_Status)

> 08 HERE: goto HERE;

> 09 return Halt_Status;

> 10 }

> 11

> 12 void main()

> 13 {

> 14 H(D,D);

> 15 }

>

> *Execution Trace*

> Line 14: main() invokes H(D,D);

>

> *keeps repeating* (unless aborted)

The input does call an H that doesn't abort, but one that does..

Thus your H is just wrong about the behavior of the input.

> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)

>

> *Simulation invariant*

> D correctly simulated by H cannot possibly reach past its own line 06.

>

> *Termination Analyzer H is Not Fooled by Pathological Input D*

> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D

>

too stupid to understand that actual qustion,

This just proves your stupidity.

You assert that a wrong answer is right, and thus your how basis of

ligic is proven to be incorrect. PERIOD.

It has EXPLODED, and you are just too dumb to realize it is dead.

Message has been deleted

Aug 23, 2023, 12:01:00 AM8/23/23

to

When it is understood that D correctly simulated by H is the behavior

that H must report on then the halting problem's otherwise impossible

input is correctly determined to be non-halting.

that H must report on then the halting problem's otherwise impossible

input is correctly determined to be non-halting.

We can know that D correctly simulated by H must have different behavior

than D(D) directly executed in main() because we can see (in its

execution trace shown below) exactly how the pathological relationship

between D and H changes the behavior of D relative to H.

*Can D correctly simulated by H terminate normally*
than D(D) directly executed in main() because we can see (in its

execution trace shown below) exactly how the pathological relationship

between D and H changes the behavior of D relative to H.

The x86utm operating system based on an open source x86 emulator. This

system enables one C function to execute another C function in debug

step mode.

system enables one C function to execute another C function in debug

step mode.

// The following is written in C

//

01 typedef int (*ptr)(); // pointer to int function

02 int H(ptr x, ptr y) // uses x86 emulator to simulate its input

03

04 int D(ptr x)

05 {

06 int Halt_Status = H(x, x);

07 if (Halt_Status)

08 HERE: goto HERE;

09 return Halt_Status;

10 }

11

12 void main()

13 {

14 H(D,D);

15 }

*Execution Trace*
//

01 typedef int (*ptr)(); // pointer to int function

02 int H(ptr x, ptr y) // uses x86 emulator to simulate its input

03

04 int D(ptr x)

05 {

06 int Halt_Status = H(x, x);

07 if (Halt_Status)

08 HERE: goto HERE;

09 return Halt_Status;

10 }

11

12 void main()

13 {

14 H(D,D);

15 }

Line 14: main() invokes H(D,D);

*keeps repeating* (unless aborted)
Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)

*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 06.

Aug 23, 2023, 12:21:15 AM8/23/23

to

On 8/23/23 12:00 AM, olcott wrote:

> When it is understood that D correctly simulated by H is the behavior

> that H must report on then the halting problem's otherwise impossible

> input is correctly determined to be non-halting.

You STILL don't get it do you!!
> When it is understood that D correctly simulated by H is the behavior

> that H must report on then the halting problem's otherwise impossible

> input is correctly determined to be non-halting.

Your H DOESN'T correctly simulate its input, thus you are just showing

yourself to be a STUPID LIAR.

You don't even seem to understand that programs do what they are

actually programmed to do, not just what you want them to do.

>

> We can know that D correctly simulated by H must have different behavior

> than D(D) directly executed in main() because we can see (in its

> execution trace shown below) exactly how the pathological relationship

> between D and H changes the behavior of D relative to H.

We can tell that as its simulation differs from the ACTUAL Correct

Simulation of this input that you previously posted.

So, it seems that you thing two things that are different can be called

the same.

>

> *Can D correctly simulated by H terminate normally*

Since H doesn't actually correctly simulate its input, it doesn't matter

what some other machine that goes by the name H does.

This is just like your "famous" questions about arresting the twin.

You are just showing how stupid you are.

> The x86utm operating system based on an open source x86 emulator. This

> system enables one C function to execute another C function in debug

> step mode.

Thus you are just a pathetic liar to say that H's correct simulation

show it doesn't

>

> // The following is written in C

> //

> 01 typedef int (*ptr)(); // pointer to int function

> 02 int H(ptr x, ptr y) // uses x86 emulator to simulate its input

> 03

> 04 int D(ptr x)

> 05 {

> 06 int Halt_Status = H(x, x);

> 07 if (Halt_Status)

> 08 HERE: goto HERE;

> 09 return Halt_Status;

> 10 }

> 11

> 12 void main()

> 13 {

> 14 H(D,D);

> 15 }

>

> *Execution Trace*

> Line 14: main() invokes H(D,D);

>

> *keeps repeating* (unless aborted)

programmed to do.

You are just admitting to being a liar.

> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)

>

> *Simulation invariant*

> D correctly simulated by H cannot possibly reach past its own line 06.

An H that correctly simulates the D built on it never answers, so fails

to be a decider.

>

>

> *Termination Analyzer H is Not Fooled by Pathological Input D*

> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D

Just your proof of your stupidity.
> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D

>

Aug 23, 2023, 12:46:25 PM8/23/23

to

A pair of C functions are defined such that D has the halting problem

proofs pathological relationship to simulating termination analyzer H.

When it is understood that D correctly simulated by H (a) Is the

behavior that H must report on (b) Cannot possibly terminate normally

then it is understood that D is correctly determined to be non-halting.

We can know that D correctly simulated by H must have different behavior

than D(D) directly executed in main() because we can see (in its

execution trace shown below) exactly how the pathological relationship

between D and H changes the behavior of D relative to H.

proofs pathological relationship to simulating termination analyzer H.

When it is understood that D correctly simulated by H (a) Is the

behavior that H must report on (b) Cannot possibly terminate normally

then it is understood that D is correctly determined to be non-halting.

We can know that D correctly simulated by H must have different behavior

than D(D) directly executed in main() because we can see (in its

execution trace shown below) exactly how the pathological relationship

between D and H changes the behavior of D relative to H.

// The following is written in C

//

01 typedef int (*ptr)(); // pointer to int function

02 int H(ptr x, ptr y) // uses x86 emulator to simulate its input

03

04 int D(ptr x)

05 {

06 int Halt_Status = H(x, x);

07 if (Halt_Status)

08 HERE: goto HERE;

09 return Halt_Status;

10 }

11

12 void main()

13 {

14 H(D,D);

15 }

*Execution Trace*
//

01 typedef int (*ptr)(); // pointer to int function

02 int H(ptr x, ptr y) // uses x86 emulator to simulate its input

03

04 int D(ptr x)

05 {

06 int Halt_Status = H(x, x);

07 if (Halt_Status)

08 HERE: goto HERE;

09 return Halt_Status;

10 }

11

12 void main()

13 {

14 H(D,D);

15 }

Line 14: main() invokes H(D,D);

*keeps repeating (unless aborted)*
Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)

*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 06.

H correctly determines that D correctly simulated by H cannot possibly

terminate normally on the basis that H recognizes a dynamic behavior

pattern equivalent to infinite recursion. H returns 0 this basis.
H correctly determines that D correctly simulated by H cannot possibly

terminate normally on the basis that H recognizes a dynamic behavior

Aug 23, 2023, 7:05:11 PM8/23/23

to

On 8/23/23 12:46 PM, olcott wrote:

> A pair of C functions are defined such that D has the halting problem

> proofs pathological relationship to simulating termination analyzer H.

> When it is understood that D correctly simulated by H (a) Is the

> behavior that H must report on (b) Cannot possibly terminate normally

> then it is understood that D is correctly determined to be non-halting.

BNo, you H doesn't "Correctly iImulate" this input, so "D correctly
> A pair of C functions are defined such that D has the halting problem

> proofs pathological relationship to simulating termination analyzer H.

> When it is understood that D correctly simulated by H (a) Is the

> behavior that H must report on (b) Cannot possibly terminate normally

> then it is understood that D is correctly determined to be non-halting.

Simulated by H" is a non-existant event, and thus, doesn't actually

assert anything. This shows you are just a hypocrite, as you claim that

you can only say something is true if it neccessary follows from the

true premises, but then insist on useing FALSE premises.

>

> We can know that D correctly simulated by H must have different behavior

> than D(D) directly executed in main() because we can see (in its

> execution trace shown below) exactly how the pathological relationship

> between D and H changes the behavior of D relative to H.

That like saying Trump must have won the last el4ction, because, reasons.'

You trace show H simulating D to the point that D calls, H, and then H

makes the ERRONEOUS assupmption that a call to H will not return, even

though H establishs (by its own action) that such a call DOES return a 0

in finite time;

Thus, H is just wrong and you are proved to be an ignorant liar.

shows that it WILL reach the final state.

The simulation that H does is of a DIFFERENT machine then actually given

to it, because it, in effecrt, closes its eyes and say "I won't look at

H, so I can say it does anything I want to say, even if it is wrong"

>

> *Termination Analyzer H is Not Fooled by Pathological Input D*

> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D

>

Aug 24, 2023, 1:47:40 PM8/24/23

to

On 8/22/2023 5:16 AM, Mikko wrote:

> On 2023-08-21 14:54:19 +0000, olcott said:

>

>> On 8/21/2023 5:54 AM, Mikko wrote:

>>> On 2023-08-20 16:06:32 +0000, olcott said:

>>>

>>>> On 8/20/2023 3:32 AM, Mikko wrote:

>>>>> On 2023-08-19 23:02:11 +0000, olcott said:

>>>>>

>>>>>> If D correctly simulated by H cannot possibly terminate normally then

>>>>>> this proves that the actual behavior of the actual input is

>>>>>> non-halting.

>>>>>

>>>>> D correctly simulated by H does not even exist unless H correctly

>>>>> simulates

>>>>> D. However, there is not need to say anything about "D correctly

>>>>> simulated

>>>>> by H" because pain "D" is sufficient.

>>>>>

>>>>> H's simulation of D is another thing. It is not the same as D although

>>>>> there is some similarity if H simulates correctly.

>>>>>

>>>>>> A halt decider is required to report on the actual behavior of the

>>>>>> actual input and it not allowed to report on any other behavior.

>>>>>

>>>>> A decider is required to tell whether a text is of the kind that

>>>>> the decider is required to identify. For a halt decider the

>>>>> requirement

>>>>> is that the text is a description of a halting computation.

>>>>>

>>>>> Mikko

>>>>>

>>>>

>>>> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X

>>>>

>>>> *Thu 10/13/2022 11:29 AM email from*

>>>> MIT Professor Michael Sipser has agreed that the following verbatim

>>>> words are correct (he has not agreed to anything else):

>>>

>>>> If simulating halt decider H correctly simulates its input D until H

>>>> correctly determines that its simulated D would never stop running

>>>> unless

>>>> aborted then H can abort its simulation of D and correctly report

>>>> that D

>>>> specifies a non-halting sequence of configurations.

>>>

>>> His opinion is that this statement is true. However, his opinion is not

>>> a definition. If you want prove something, you must start with

>>> definitons,

>>> not with opinions.

>>>

>>> Mikko

>>>

>>

>> He agreed with my verbatim words.

>

> An agreement of opionions is not a proof.

>

>> Many people noticed that these words are a tautology thus

>> a necessary truth.

>

> That is a semantic tautology, i.e., it is a tautology only if correctly

> interpreted.

>

>> When D correctly simulated by H cannot possibly terminate normally

>> and halting requires terminating normally then the D input to H

>> is necessarily non-halting.

>

> The D that H simulates does terminate normally. H just fails to simulate

> D to normal termination.

>

> Mikko

>

*All of my reviews have been specifically counter-factual*

The source-code of D and H proves that D correctly simulated

by H cannot possibly terminate normally because D continues

to call H in recursive simulation unless the system crashes

because of stack overflow or H aborts its simulation of D.

When D is correctly simulated by H the source-code of D and H

requires that the pathological relationship that D defines

with H must be simulated.

All of my reviewers simply counter-factually ignore what the

source-code specifies. This is either incompetent or dishonest.

> On 2023-08-21 14:54:19 +0000, olcott said:

>

>> On 8/21/2023 5:54 AM, Mikko wrote:

>>> On 2023-08-20 16:06:32 +0000, olcott said:

>>>

>>>> On 8/20/2023 3:32 AM, Mikko wrote:

>>>>> On 2023-08-19 23:02:11 +0000, olcott said:

>>>>>

>>>>>> If D correctly simulated by H cannot possibly terminate normally then

>>>>>> this proves that the actual behavior of the actual input is

>>>>>> non-halting.

>>>>>

>>>>> D correctly simulated by H does not even exist unless H correctly

>>>>> simulates

>>>>> D. However, there is not need to say anything about "D correctly

>>>>> simulated

>>>>> by H" because pain "D" is sufficient.

>>>>>

>>>>> H's simulation of D is another thing. It is not the same as D although

>>>>> there is some similarity if H simulates correctly.

>>>>>

>>>>>> A halt decider is required to report on the actual behavior of the

>>>>>> actual input and it not allowed to report on any other behavior.

>>>>>

>>>>> A decider is required to tell whether a text is of the kind that

>>>>> the decider is required to identify. For a halt decider the

>>>>> requirement

>>>>> is that the text is a description of a halting computation.

>>>>>

>>>>> Mikko

>>>>>

>>>>

>>>> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X

>>>>

>>>> *Thu 10/13/2022 11:29 AM email from*

>>>> MIT Professor Michael Sipser has agreed that the following verbatim

>>>> words are correct (he has not agreed to anything else):

>>>

>>>> If simulating halt decider H correctly simulates its input D until H

>>>> correctly determines that its simulated D would never stop running

>>>> unless

>>>> aborted then H can abort its simulation of D and correctly report

>>>> that D

>>>> specifies a non-halting sequence of configurations.

>>>

>>> His opinion is that this statement is true. However, his opinion is not

>>> a definition. If you want prove something, you must start with

>>> definitons,

>>> not with opinions.

>>>

>>> Mikko

>>>

>>

>> He agreed with my verbatim words.

>

> An agreement of opionions is not a proof.

>

>> Many people noticed that these words are a tautology thus

>> a necessary truth.

>

> That is a semantic tautology, i.e., it is a tautology only if correctly

> interpreted.

>

>> When D correctly simulated by H cannot possibly terminate normally

>> and halting requires terminating normally then the D input to H

>> is necessarily non-halting.

>

> The D that H simulates does terminate normally. H just fails to simulate

> D to normal termination.

>

> Mikko

>

*All of my reviews have been specifically counter-factual*

The source-code of D and H proves that D correctly simulated

by H cannot possibly terminate normally because D continues

to call H in recursive simulation unless the system crashes

because of stack overflow or H aborts its simulation of D.

When D is correctly simulated by H the source-code of D and H

requires that the pathological relationship that D defines

with H must be simulated.

All of my reviewers simply counter-factually ignore what the

source-code specifies. This is either incompetent or dishonest.

Aug 24, 2023, 6:44:21 PM8/24/23

to

Since H(D,D) DOES return 0, then we have proof that the correct

simulation of the input to H will halt, and thus H is wrong.

Yes, we can show that if we had some other H that actually does a

correct simulation of its input, then the other D that is built from

that H will be non-halting, but also that such an other H will never

return an answer.

Since that is a DIFFERENT input, it doesn't appply hear, and you are

just proving you don't understand anything about what you are talking

about. If is just fabrication to talk about a program doing behavior

that it doesn't do, but apparently that is the only sort of logic you

can do. You are just proving you are a LIAR.

>

> When D is correctly simulated by H the source-code of D and H

> requires that the pathological relationship that D defines

> with H must be simulated.

show that the moon is edible.

THe problem with your logic is that H DOESN'T "correctly simulate" D, so

if you make that a premise to your arguement, you are just showing you

are unsound.

>

> All of my reviewers simply counter-factually ignore what the

> source-code specifies. This is either incompetent or dishonest >

own code works or what the words you are using actually mean.

You have killed you reputation and will only be remembered as aan

ignorant pathological liar.

Aug 25, 2023, 2:48:10 PM8/25/23

to

A pair of C functions are defined such that D has the halting problem

proof's pathological relationship to simulating termination analyzer H.
When it is understood that D correctly simulated by H (a) Is the

behavior that H must report on and (b) Cannot possibly terminate
normally then it is understood that D is correctly determined to be non-

halting.

halting.

We can know that D correctly simulated by H must have different behavior

than D(D) directly executed in main() because we can see (in its

execution trace shown below) exactly how the pathological relationship

between D and H changes the behavior of D relative to H.

than D(D) directly executed in main() because we can see (in its

execution trace shown below) exactly how the pathological relationship

between D and H changes the behavior of D relative to H.

For any program H that might determine whether programs halt, a

"pathological" program D, called with some input, can pass its own

source and its input to H and then specifically do the opposite of what

H predicts D will do. No H can exist that handles this case.

https://en.wikipedia.org/wiki/Halting_problem

"pathological" program D, called with some input, can pass its own

source and its input to H and then specifically do the opposite of what

H predicts D will do. No H can exist that handles this case.

https://en.wikipedia.org/wiki/Halting_problem

"A decision problem is a yes-or-no question on an infinite set of

inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition

Can D correctly simulated by H terminate normally?

The x86utm operating system: https://github.com/plolcott/x86utm
inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition

Can D correctly simulated by H terminate normally?

is based on an open source x86 emulator. x86utm enables one C function

to execute another C function in debug step mode.

// The following is written in C

//

01 typedef int (*ptr)(); // pointer to int function

02 int H(ptr x, ptr y) // uses x86 emulator to simulate its input

03

04 int D(ptr x)

05 {

06 int Halt_Status = H(x, x);

07 if (Halt_Status)

08 HERE: goto HERE;

09 return Halt_Status;

10 }

11

12 void main()

13 {

14 H(D,D);

15 }

*Execution Trace*
//

01 typedef int (*ptr)(); // pointer to int function

02 int H(ptr x, ptr y) // uses x86 emulator to simulate its input

03

04 int D(ptr x)

05 {

06 int Halt_Status = H(x, x);

07 if (Halt_Status)

08 HERE: goto HERE;

09 return Halt_Status;

10 }

11

12 void main()

13 {

14 H(D,D);

15 }

Line 14: main() invokes H(D,D);

*keeps repeating* (unless aborted)
Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)

*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 06.

H correctly determines that D correctly simulated by H cannot possibly

terminate normally on the basis that H recognizes a dynamic behavior

pattern equivalent to infinite recursion. H returns 0 this basis.
H correctly determines that D correctly simulated by H cannot possibly

terminate normally on the basis that H recognizes a dynamic behavior

*ADDENDUM*

(1) The source-code of H and D conclusively proves that D correctly

simulated by H cannot possibly terminate normally.

*THIS IS THE PART THAT EVERYONE LIES ABOUT*

(2) The correct simulation of D by H must include the fact that

D would continue to call H until stack overflow crash unless H

aborts its simulation of D.

(3) (2) Means that D is correctly simulated by H and this correctly
simulated D is non-halting.

(4) "A decision problem is a yes-or-no question on an infinite set

of inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition

This means that the behavior of non-inputs is not allowed to be

considered.

Aug 25, 2023, 7:23:33 PM8/25/23

to

You keep on making the same mistakes,

On 8/25/23 2:48 PM, olcott wrote:

> A pair of C functions are defined such that D has the halting problem

> proof's pathological relationship to simulating termination analyzer H.

> When it is understood that D correctly simulated by H (a) Is the

> behavior that H must report on and (b) Cannot possibly terminate

> normally then it is understood that D is correctly determined to be non-

> halting.

So, you are STIPULATING, that since D(x) calls H(x,x), that this means

askin H about the behavior of the program x given the input x, which

means that D(D) callihg H(D,D) means it is asking H about the behavior

of the program D(D)

>

> We can know that D correctly simulated by H must have different behavior

> than D(D) directly executed in main() because we can see (in its

> execution trace shown below) exactly how the pathological relationship

> between D and H changes the behavior of D relative to H.

Nope, that statement just PROVES that you don't understand the meaning

of the words you are using, and are just a ignorant pathological lying

idiot.

>

> "A decision problem is a yes-or-no question on an infinite set of

> inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition

>

Right and a "X decider problem" means the decider must answer based on

the definition of problem X, and a "Halt Decider" must answer based on

whether to program described by its input will halt.

> Can D correctly simulated by H terminate normally?

Improper question. Have you stopped lying? (that one actually has an

answer, NO).

Since H doen't actually correctly simulate its input, the question is

based on a false premise.

> The x86utm operating system: https://github.com/plolcott/x86utm

> is based on an open source x86 emulator. x86utm enables one C function

> to execute another C function in debug step mode.

>

And your program shows that D(D) DOES HALT, and thus H's answer is WRONG>

> // The following is written in C

> //

> 01 typedef int (*ptr)(); // pointer to int function

> 02 int H(ptr x, ptr y) // uses x86 emulator to simulate its input

> 03

> 04 int D(ptr x)

> 05 {

> 06 int Halt_Status = H(x, x);

> 07 if (Halt_Status)

> 08 HERE: goto HERE;

> 09 return Halt_Status;

> 10 }

> 11

> 12 void main()

> 13 {

> 14 H(D,D);

> 15 }

>

> *Execution Trace*

> Line 14: main() invokes H(D,D);

>

> *keeps repeating* (unless aborted)

LIE.

You H does no such thing, you don't seem to understand that programs do

what they are actually programmed to do.

You are just proving you don't understand the meaning of words like

"Program", "Correct" or even "Logic"

> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)

Right, your H is defined to ALWAYS abort its simulation of this input,

the, your statement of "keeps repeating" is just a LIE. You condition is

irrelevent.

>

> *Simulation invariant*

A meanilngless term (par for you) since in the problem we have a SINGLE

H, with a specified input, so there is nothing to "Vary", so we can't

have an "invariant".

At best, you mean, if we look over all possible H's that meet your

general definition, we can prove the following for all of them.

> D correctly simulated by H cannot possibly reach past its own line 06.

Which is a correct conclusion, it is IMPOSSIBLE for any H to be able to

simulate the program built by the template to that final state.

THe problem is that this just proves that NO H can, by your logic, can

show that its input is Halting. It says NOTHING about not it being

non-halting.

Remember, every H in this set is a different problem, and creates a

different input, so the results obtained about one input says nothing

about a different one.

>

> H correctly determines that D correctly simulated by H cannot possibly

> terminate normally on the basis that H recognizes a dynamic behavior

> pattern equivalent to infinite recursion. H returns 0 this basis.

Nope. UNSOUND LOGIC. Since any H that aborts its simulation doesn't do a

"Correct SImulation", you don't have anything to make your deduction on.

You are just proving your stupidity.

>

> *ADDENDUM*

>

> (1) The source-code of H and D conclusively proves that D correctly

> simulated by H cannot possibly terminate normally.

But ONLY if H DOES correctly simulate its input, at which point it never

aborts, and thus, as you proved above, it never answers.

>

> *THIS IS THE PART THAT EVERYONE LIES ABOUT*

> (2) The correct simulation of D by H must include the fact that

> D would continue to call H until stack overflow crash unless H

> aborts its simulation of D.

Nope, a correcrt simulaiton of D by ANYTHING (includeing H) must include

the ACTUAL behavior of H, not the behavior of some other program.

>

> (3) (2) Means that D is correctly simulated by H and this correctly

> simulated D is non-halting.

>

Nope, just shows you don't understand what correct logic requires.

> (4) "A decision problem is a yes-or-no question on an infinite set

> of inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition

> This means that the behavior of non-inputs is not allowed to be

> considered.

>

Right, and it needs to give the correct answer to be correct.

You are just proving that you are an ignorant pathological lying idiot.

>

>

> *Termination Analyzer H is Not Fooled by Pathological Input D*

> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D

>

>

Just shows your stupidity to the world.

Note, the fact that you keep on making the same DISPROVEN claims, shows

you are just a brain damaged insane moron.

You seem to be incapable of learning.

This seems to prove that you are just a pathological liar.

On 8/25/23 2:48 PM, olcott wrote:

> A pair of C functions are defined such that D has the halting problem

> proof's pathological relationship to simulating termination analyzer H.

> When it is understood that D correctly simulated by H (a) Is the

> behavior that H must report on and (b) Cannot possibly terminate

> normally then it is understood that D is correctly determined to be non-

> halting.

askin H about the behavior of the program x given the input x, which

means that D(D) callihg H(D,D) means it is asking H about the behavior

of the program D(D)

>

> We can know that D correctly simulated by H must have different behavior

> than D(D) directly executed in main() because we can see (in its

> execution trace shown below) exactly how the pathological relationship

> between D and H changes the behavior of D relative to H.

of the words you are using, and are just a ignorant pathological lying

idiot.

>

> For any program H that might determine whether programs halt, a

> "pathological" program D, called with some input, can pass its own

> source and its input to H and then specifically do the opposite of what

> H predicts D will do. No H can exist that handles this case.

> https://en.wikipedia.org/wiki/Halting_problem

So? what is wrong with the fact that no H can exist that handles this case?
> For any program H that might determine whether programs halt, a

> "pathological" program D, called with some input, can pass its own

> source and its input to H and then specifically do the opposite of what

> H predicts D will do. No H can exist that handles this case.

> https://en.wikipedia.org/wiki/Halting_problem

>

> "A decision problem is a yes-or-no question on an infinite set of

> inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition

>

the definition of problem X, and a "Halt Decider" must answer based on

whether to program described by its input will halt.

> Can D correctly simulated by H terminate normally?

answer, NO).

Since H doen't actually correctly simulate its input, the question is

based on a false premise.

> The x86utm operating system: https://github.com/plolcott/x86utm

> is based on an open source x86 emulator. x86utm enables one C function

> to execute another C function in debug step mode.

>

> // The following is written in C

> //

> 01 typedef int (*ptr)(); // pointer to int function

> 02 int H(ptr x, ptr y) // uses x86 emulator to simulate its input

> 03

> 04 int D(ptr x)

> 05 {

> 06 int Halt_Status = H(x, x);

> 07 if (Halt_Status)

> 08 HERE: goto HERE;

> 09 return Halt_Status;

> 10 }

> 11

> 12 void main()

> 13 {

> 14 H(D,D);

> 15 }

>

> *Execution Trace*

> Line 14: main() invokes H(D,D);

>

> *keeps repeating* (unless aborted)

You H does no such thing, you don't seem to understand that programs do

what they are actually programmed to do.

You are just proving you don't understand the meaning of words like

"Program", "Correct" or even "Logic"

> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)

the, your statement of "keeps repeating" is just a LIE. You condition is

irrelevent.

>

> *Simulation invariant*

A meanilngless term (par for you) since in the problem we have a SINGLE

H, with a specified input, so there is nothing to "Vary", so we can't

have an "invariant".

At best, you mean, if we look over all possible H's that meet your

general definition, we can prove the following for all of them.

> D correctly simulated by H cannot possibly reach past its own line 06.

simulate the program built by the template to that final state.

THe problem is that this just proves that NO H can, by your logic, can

show that its input is Halting. It says NOTHING about not it being

non-halting.

Remember, every H in this set is a different problem, and creates a

different input, so the results obtained about one input says nothing

about a different one.

>

> H correctly determines that D correctly simulated by H cannot possibly

> terminate normally on the basis that H recognizes a dynamic behavior

> pattern equivalent to infinite recursion. H returns 0 this basis.

"Correct SImulation", you don't have anything to make your deduction on.

You are just proving your stupidity.

>

> *ADDENDUM*

>

> (1) The source-code of H and D conclusively proves that D correctly

> simulated by H cannot possibly terminate normally.

aborts, and thus, as you proved above, it never answers.

>

> *THIS IS THE PART THAT EVERYONE LIES ABOUT*

> (2) The correct simulation of D by H must include the fact that

> D would continue to call H until stack overflow crash unless H

> aborts its simulation of D.

the ACTUAL behavior of H, not the behavior of some other program.

>

> (3) (2) Means that D is correctly simulated by H and this correctly

> simulated D is non-halting.

>

> (4) "A decision problem is a yes-or-no question on an infinite set

> of inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition

> This means that the behavior of non-inputs is not allowed to be

> considered.

>

You are just proving that you are an ignorant pathological lying idiot.

>

>

> *Termination Analyzer H is Not Fooled by Pathological Input D*

> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D

>

>

Note, the fact that you keep on making the same DISPROVEN claims, shows

you are just a brain damaged insane moron.

You seem to be incapable of learning.

This seems to prove that you are just a pathological liar.

Aug 27, 2023, 11:00:43 AM8/27/23

to

believe] makes pretend that it is simulating D(D) directly executed in

main() then the actual D that H is actually simulating will crash from

stack overflow because H will never stop simulating D.

This conclusively proves that D is correct to abort its simulation and

return 0 indicating that D correctly simulated by H cannot possibly

terminate normally.

Aug 27, 2023, 12:28:51 PM8/27/23

to

So, you STILL don't understand that a program does what it is actually

programmed to do, and nothing else,

And to talk about what a program "would" have done if, as something

different than what it actually does, is just a LIE.

H can't make a correct decision based on behavior of a DIFFERENT program

given a DIFFERENT input and say this answer applies here.

The question that H MUST answer, is "Does the machine represented by its

input Halt?"

Since H(D,D) returns 0, it is shown that D(D) Halts, and thus the

CORRECT answer for a Halt Decider is Halting, so H is just WRONG.

You are just proving yourself to be an ignorant pathological lying idiot

that just doesn't know what he is talking about.

YOU FAIL.

Just repeating your same claim over and over just proves you are INSANE,

as well as Stupid, and incapable of learning, and can't actually do any

real logic.

programmed to do, and nothing else,

And to talk about what a program "would" have done if, as something

different than what it actually does, is just a LIE.

H can't make a correct decision based on behavior of a DIFFERENT program

given a DIFFERENT input and say this answer applies here.

The question that H MUST answer, is "Does the machine represented by its

input Halt?"

Since H(D,D) returns 0, it is shown that D(D) Halts, and thus the

CORRECT answer for a Halt Decider is Halting, so H is just WRONG.

You are just proving yourself to be an ignorant pathological lying idiot

that just doesn't know what he is talking about.

YOU FAIL.

Just repeating your same claim over and over just proves you are INSANE,

as well as Stupid, and incapable of learning, and can't actually do any

real logic.

Aug 27, 2023, 1:13:06 PM8/27/23

to

simulated by H there are only a THREE categories of possible

behaviors for H: (1)(a), (1)(b) and (2)

(1) Abort its simulation of D after a finite number of steps:

(a) Return 0 indicating that D correctly simulated by H cannot

possibly terminate normally.

(b) Return 1 indicating that D correctly simulated by H will

terminate normally.

(2) Never abort its simulation of D.

Anyone having a sufficient knowledge of C can correctly determine which

of these options are incorrect on the basis of the source-code of D.

Aug 27, 2023, 1:27:10 PM8/27/23

to

Remember, each was given a DIFFERENT input, as you are giving it the D

built on IT, so each is a DIFFERENET input

So, you just proved what you claimed to refute, because you are actually

THAT STUPID.

Problem Statement: H needs to return correct answer that corresponds to

the actual behavior of the machine represented by its input when it is run.

Class 1a:

H aborts its simulation after some time and returns 0 (saying non-halting)

By the definition of D, that D, when actually run, will get that 0

returned and then HALT.

So H was wrong.

Class 1b:

H aborts its simulation after some time and returns 1 (Saying Halting).

By the definition of D, that D, when actually run, will get that 1

returned to it, and then go into an infinite loop, and never halt.

So H was wrong.

Class 2:

H never aborts is simulation of D, and thus gets stuck in an infinite

recursion and thus never gives an answer.

So H is wrong.

Thus, you have shown that for EVERY POSSIBLE H, built by you system,

NONE of them gave the correct answer for its input.

You are just proving that you are lying about working on the problem

that you claim you are, likely because you are just too stupid to

understand it.

You seem to think that one program can be all of the above, and its

input is also all of the above.

That shows you don't understand what a "program" is.

YOU FAIL.

Aug 27, 2023, 3:31:20 PM8/27/23

to

input that deliberately contradicts whatever Boolean value that this

termination analyzer returns the halting problem merely mirrors the Liar

Paradox.

The Liar Paradox cannot be correctly resolved to a value of True or

False only because it is semantically unsound because it is self-

contradictory.

Thus the inability of a termination analyzer to provide a correct

Boolean return value is analogous to a CAD system's inability to

correctly draw a square circle. Thus this interpretation of the halting

problem is merely an artificial contrivance with no actual merit.

Aug 27, 2023, 3:52:46 PM8/27/23

to

To be applicable to the problem, your "Termination Analyzer" must be an

actual program, and thus it must give an actual answer.

IF H is this "Termination Analyzer" then it also must be an actual

program an d thus gives an actual specific answer for any specific input.

The input D, built on the program H, WILL be an actual program (since H

is) and thus is in the domain of the Analyzer, since the problem

statement says for ANY program.

The question the program is to answer is "Does the program represented

by the input to the decider Halt when run?"

Since you stipulate that H(D,D) WILL return 0 (and incorrectly claim

this to be correct) a simple analysis of the code of D shows that it

WILL halt. in part BECAUSE H(D,D) return 0.

Thus, the CORRECT answer is Halt.

THe answer given by H was Non-Halting, and thus is WRONG.

>

> The Liar Paradox cannot be correctly resolved to a value of True or

> False only because it is semantically unsound because it is self-

> contradictory.

equivalent to the liar's paradox.

Your alternate quesition, what can be build an H to return for this

case, IS an equivalent to the liars paradox, which doesn't make the

original question of the Halting Problem invalid, it just shows that we

can't actually build such a machine (at least by the method you are

investigating) and thus just provides support (or proves if you clean

things up a bit) that the Halting Function is non-computable and thus we

can not make a program that answers the Halting Problem.

>

> Thus the inability of a termination analyzer to provide a correct

> Boolean return value is analogous to a CAD system's inability to

> correctly draw a square circle. Thus this interpretation of the halting

> problem is merely an artificial contrivance with no actual merit.

Halting Problem?

Then way do you say you have disproved the very thing you agreed with?

You seem to be confused.

Aug 28, 2023, 11:06:00 AM8/28/23

to

N such that N > 5 and N < 2 is "undecidable".

When a termination analyzer must return a Boolean value that provides

the halt status of and D does the opposite of whatever Boolean value

that H returns the halting problem is a mere ruse and not any legitimate

decision problem at all.

This only happens when we expect H to determine the halt status of a

non-input.

int sum(int x, int y)

{

return x + y;

}

When for forbid H to report on not inputs this is the same as

forbidding sum(3,4) to report on the sum of 5 + 7.

When for forbid H to report on not inputs then the halting problem

counter-example is decidable by a simulating termination analyzer.

Aug 28, 2023, 7:00:50 PM8/28/23

to

is Halting, BECAUSE your H answers non-halting, and THAT H always will

as that is the only thing THAT H can do as that is what it is programmed

to do. So THIS H is just wrong, the problem isn't "undecidabe"

If you want to try to create an other H that answers Halting for the D

built on it, that OTHER D will just go into a loop and be non-halting,

so that other H is also wrong.

If you make even another H that doesn't abort its simulation, it will

just be wrong by not answering.

Note, you don't even HAVE a "Halting Question" to answer until you

actauly define your Halt Decider, so the problem that is "undecidable"

can't be the "Halting Problem", as it doesn't exist until we have the

input program, and we can't have the program "D" until we have the

program H, fully defined, and at that point, the answer exists (as

described above).

So, the only "undecidable" question you are talking about is one that

isn't the Halting Problem, so you logic is just unsound.

>

> When a termination analyzer must return a Boolean value that provides

> the halt status of and D does the opposite of whatever Boolean value

> that H returns the halting problem is a mere ruse and not any legitimate

> decision problem at all.

it doesn't have an answer.

>

> This only happens when we expect H to determine the halt status of a

> non-input.

You are just proving you don't understand what you are talking about.

>

> int sum(int x, int y)

> {

> return x + y;

> }

>

> When for forbid H to report on not inputs this is the same as

> forbidding sum(3,4) to report on the sum of 5 + 7.

perfectly free to give what ever answer it wants (as long as that it

swhat is has been programmed to do, as all programs onlygive the answers

they have been programmed to do). The only issue is that, becaus the

input is build on using a copy of the decider, as ALLOWED by the theory

of computability, that answer will justbe wrong.

Remember, "Get the right answer" is NOT a "program", but you need to

actually find (if it is possible) a computation that generates the right

answer.

>

> When for forbid H to report on not inputs then the halting problem

> counter-example is decidable by a simulating termination analyzer.

of the input for a Halt Decider, so you are just admitting that you are

lying that your H actually is a Halt Decider.

Thus, you are admitting that you are just wrong.

But are too stupid to know what you are talking about.

0 new messages