Can D 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 D(D);
15 }

Execution Trace
Line 14: main() invokes 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 its own line 09.

Is it dead obvious to everyone here when examining the execution
trace of lines 14 and 06 above that D correctly simulated by H cannot
possibly terminate normally by reaching its own line 09?

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

On 4/27/24 8:17 PM, olcott wrote:
> Can D 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   D(D);
> 15 }
>
> Execution Trace
> Line 14: main() invokes 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 its own line 09.
>
> Is it dead obvious to everyone here when examining the execution
> trace of lines 14 and 06 above that D correctly simulated by H cannot
> possibly terminate normally by reaching its own line 09?
>
>

Except that you fail to mention that you have admitted that you are NOT
working on the Halting Problem, despite trying to use terminology
similar to it, but having stipulated definition that are in conflict
with computaiton theory.

Note, "keeps repeating (unless aborted)" is a misleading statement, as
your H will ALWAYS abort this input, and thus it NEVER will "Keep
repeating".

You don't like me pointing out the problem because you prefer to be able
to LIE to people about what you are doing.

You work has NOTHING to do with Halting, as your H/D are not even turing
equivalenet to their namesakes in the proof you like to mention.

On 4/27/2024 7:49 PM, Richard Damon wrote:
> On 4/27/24 8:17 PM, olcott wrote:
>> Can D 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   D(D);
>> 15 }
>>
>> Execution Trace
>> Line 14: main() invokes 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 its own line 09.
>>
>> Is it dead obvious to everyone here when examining the execution
>> trace of lines 14 and 06 above that D correctly simulated by H cannot
>> possibly terminate normally by reaching its own line 09?
>>
>>
>
> Except that you fail to mention that you have admitted that you are NOT
> working on the Halting Problem, despite trying to use terminology
> similar to it, but having stipulated definition that are in conflict
> with computaiton theory.
>
> Note, "keeps repeating (unless aborted)" is a misleading statement, as
> your H will ALWAYS abort this input, and thus it NEVER will "Keep
> repeating".
>
> You don't like me pointing out the problem because you prefer to be able
> to LIE to people about what you are doing.
>
> You work has NOTHING to do with Halting, as your H/D are not even turing
> equivalenet to their namesakes in the proof you like to mention.

That is the exact verbatim post and the first respondent agreed
and immediately noticed that I was referring to the halting problem.

So I will go with what I said, you just don't know C very
well and want to keep that hidden behind rhetoric and denigration.

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

On 4/27/24 8:58 PM, olcott wrote:
> On 4/27/2024 7:49 PM, Richard Damon wrote:
>> On 4/27/24 8:17 PM, olcott wrote:
>>> Can D 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   D(D);
>>> 15 }
>>>
>>> Execution Trace
>>> Line 14: main() invokes 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 its own line 09.
>>>
>>> Is it dead obvious to everyone here when examining the execution
>>> trace of lines 14 and 06 above that D correctly simulated by H cannot
>>> possibly terminate normally by reaching its own line 09?
>>>
>>>
>>
>> Except that you fail to mention that you have admitted that you are
>> NOT working on the Halting Problem, despite trying to use terminology
>> similar to it, but having stipulated definition that are in conflict
>> with computaiton theory.
>>
>> Note, "keeps repeating (unless aborted)" is a misleading statement, as
>> your H will ALWAYS abort this input, and thus it NEVER will "Keep
>> repeating".
>>
>> You don't like me pointing out the problem because you prefer to be
>> able to LIE to people about what you are doing.
>>
>> You work has NOTHING to do with Halting, as your H/D are not even
>> turing equivalenet to their namesakes in the proof you like to mention.
>
> That is the exact verbatim post and the first respondent agreed
> and immediately noticed that I was referring to the halting problem.
>
> So I will go with what I said, you just don't know C very
> well and want to keep that hidden behind rhetoric and denigration.
>
>

Yes, you couch it to SOUND like the halting problem, but it isn't as you
have FUNDAMENTALLY CHANGED the meaning of terms.

And thus, to act like it is, just makes you a LIAR.

Halting is NOT about H being able to simulate it input to the final
state. PERIOD.

You are just showing that you are NOT out to promote truth, but to try
to infiltrate logic with your ERRORS and LIES to allow you to claim
things that are just not true, just like those you try to put down, like
the election denyers.

You are WORSE than them.

On 4/27/2024 8:39 PM, Richard Damon wrote:
> On 4/27/24 8:58 PM, olcott wrote:
>> On 4/27/2024 7:49 PM, Richard Damon wrote:
>>> On 4/27/24 8:17 PM, olcott wrote:
>>>> Can D 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   D(D);
>>>> 15 }
>>>>
>>>> Execution Trace
>>>> Line 14: main() invokes 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 its own line 09.
>>>>
>>>> Is it dead obvious to everyone here when examining the execution
>>>> trace of lines 14 and 06 above that D correctly simulated by H cannot
>>>> possibly terminate normally by reaching its own line 09?
>>>>
>>>>
>>>
>>> Except that you fail to mention that you have admitted that you are
>>> NOT working on the Halting Problem, despite trying to use terminology
>>> similar to it, but having stipulated definition that are in conflict
>>> with computaiton theory.
>>>
>>> Note, "keeps repeating (unless aborted)" is a misleading statement,
>>> as your H will ALWAYS abort this input, and thus it NEVER will "Keep
>>> repeating".
>>>
>>> You don't like me pointing out the problem because you prefer to be
>>> able to LIE to people about what you are doing.
>>>
>>> You work has NOTHING to do with Halting, as your H/D are not even
>>> turing equivalenet to their namesakes in the proof you like to mention.
>>
>> That is the exact verbatim post and the first respondent agreed
>> and immediately noticed that I was referring to the halting problem.
>>
>> So I will go with what I said, you just don't know C very
>> well and want to keep that hidden behind rhetoric and denigration.
>>
>>
>
>
> Yes, you couch it to SOUND like the halting problem, but it isn't as you
> have FUNDAMENTALLY CHANGED the meaning of terms.
>
> And thus, to act like it is, just makes you a LIAR.
>
> Halting is NOT about H being able to simulate it input to the final
> state. PERIOD.
>

I could show how it is but you prefer to believe otherwise and refuse
to go through the detailed steps required.

It is psychotic that people really believes that the principle of
explosion is valid inference even though there is zero doubt the it
derives the non-sequitur error.

*When we encode the principle of explosion as a syllogism*
Socrates is a man.
Socrates is not a man.
Therefore, Socrates is a butterfly.

The conclusion does not follow from the premises, thus the non-sequitur
error. https://en.wikipedia.org/wiki/Principle_of_explosion

Marilyn Vos Savant has a simple explanation for this:
Most everyone is simply indoctrinated to conform thus loses the
ability to think for themselves.

> You are just showing that you are NOT out to promote truth, but to try
> to infiltrate logic with your ERRORS and LIES to allow you to claim
> things that are just not true, just like those you try to put down, like
> the election denyers.
>
> You are WORSE than them.

And you too are sure that the Principle of Explosion of explosion is
valid inference because like most everyone you believe that textbooks
are inherently infallible, thus when they directly contradict each
other this "word of God" is simply beyond human comprehension.

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

On 4/27/24 9:54 PM, olcott wrote:
> On 4/27/2024 8:39 PM, Richard Damon wrote:
>> On 4/27/24 8:58 PM, olcott wrote:
>>> On 4/27/2024 7:49 PM, Richard Damon wrote:
>>>> On 4/27/24 8:17 PM, olcott wrote:
>>>>> Can D 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   D(D);
>>>>> 15 }
>>>>>
>>>>> Execution Trace
>>>>> Line 14: main() invokes 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 its own line 09.
>>>>>
>>>>> Is it dead obvious to everyone here when examining the execution
>>>>> trace of lines 14 and 06 above that D correctly simulated by H cannot
>>>>> possibly terminate normally by reaching its own line 09?
>>>>>
>>>>>
>>>>
>>>> Except that you fail to mention that you have admitted that you are
>>>> NOT working on the Halting Problem, despite trying to use
>>>> terminology similar to it, but having stipulated definition that are
>>>> in conflict with computaiton theory.
>>>>
>>>> Note, "keeps repeating (unless aborted)" is a misleading statement,
>>>> as your H will ALWAYS abort this input, and thus it NEVER will "Keep
>>>> repeating".
>>>>
>>>> You don't like me pointing out the problem because you prefer to be
>>>> able to LIE to people about what you are doing.
>>>>
>>>> You work has NOTHING to do with Halting, as your H/D are not even
>>>> turing equivalenet to their namesakes in the proof you like to mention.
>>>
>>> That is the exact verbatim post and the first respondent agreed
>>> and immediately noticed that I was referring to the halting problem.
>>>
>>> So I will go with what I said, you just don't know C very
>>> well and want to keep that hidden behind rhetoric and denigration.
>>>
>>>
>>
>>
>> Yes, you couch it to SOUND like the halting problem, but it isn't as
>> you have FUNDAMENTALLY CHANGED the meaning of terms.
>>
>> And thus, to act like it is, just makes you a LIAR.
>>
>> Halting is NOT about H being able to simulate it input to the final
>> state. PERIOD.
>>
>
> I could show how it is but you prefer to believe otherwise and refuse
> to go through the detailed steps required.

No, you CAN'T, because you have FUNDAMENTALLY changed the question, sinc
eyou claim that even though D(D) Halts, that H(D,D) is correct to say
not halting.

>
> It is psychotic that people really believes that the principle of
> explosion is valid inference even though there is zero doubt the it
> derives the non-sequitur error.

Nope, that just means you don't understand how logic works.

YOU are the psychotic.

>
> *When we encode the principle of explosion as a syllogism*
> Socrates is a man.
> Socrates is not a man.
> Therefore, Socrates is a butterfly.

Nope. And that is because the principle of explosion is NOT a "syllogism"

You are again just proving your stupidity.

>
> The conclusion does not follow from the premises, thus the non-sequitur
> error. https://en.wikipedia.org/wiki/Principle_of_explosion

So, which step doesn't is incorrect.

Givens:
Proposition A is True.
Proposition A is False.

Goal:
Prove B

Steps
1) Since True | x is always true
2) and A is True (1st Given)
3) The statement A | B must be true.
4) Since if False | x is true, x must be true
5) and A is False (2nd Given)
6) and A | B is True (from 3)
7) it must be that B is True.
QED

Where is the error?

>
> Marilyn Vos Savant has a simple explanation for this:
> Most everyone is simply indoctrinated to conform thus loses the
> ability to think for themselves.
>
>> You are just showing that you are NOT out to promote truth, but to try
>> to infiltrate logic with your ERRORS and LIES to allow you to claim
>> things that are just not true, just like those you try to put down,
>> like the election denyers.
>>
>> You are WORSE than them.
>
> And you too are sure that the Principle of Explosion of explosion is
> valid inference because like most everyone you believe that textbooks
> are inherently infallible, thus when they directly contradict each
> other this "word of God" is simply beyond human comprehension.
>

If you think it isn't a valid inference, point out the error in the
proof of it above.

All you are doing is proving that you don't actually believe in logic.

This explains most of your errors and why your speach is so full of
lies, you don't actually believe in the concepts of Logic, or Truth, but
they are just objects to be manipulated to try to get your way.

Your native tongue is Lies, as it was of your father below.

On 4/27/2024 9:09 PM, Richard Damon wrote:
> On 4/27/24 9:54 PM, olcott wrote:
>> On 4/27/2024 8:39 PM, Richard Damon wrote:
>>> On 4/27/24 8:58 PM, olcott wrote:
>>>> On 4/27/2024 7:49 PM, Richard Damon wrote:
>>>>> On 4/27/24 8:17 PM, olcott wrote:
>>>>>> Can D 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   D(D);
>>>>>> 15 }
>>>>>>
>>>>>> Execution Trace
>>>>>> Line 14: main() invokes 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 its own line 09.
>>>>>>
>>>>>> Is it dead obvious to everyone here when examining the execution
>>>>>> trace of lines 14 and 06 above that D correctly simulated by H cannot
>>>>>> possibly terminate normally by reaching its own line 09?
>>>>>>
>>>>>>
>>>>>
>>>>> Except that you fail to mention that you have admitted that you are
>>>>> NOT working on the Halting Problem, despite trying to use
>>>>> terminology similar to it, but having stipulated definition that
>>>>> are in conflict with computaiton theory.
>>>>>
>>>>> Note, "keeps repeating (unless aborted)" is a misleading statement,
>>>>> as your H will ALWAYS abort this input, and thus it NEVER will
>>>>> "Keep repeating".
>>>>>
>>>>> You don't like me pointing out the problem because you prefer to be
>>>>> able to LIE to people about what you are doing.
>>>>>
>>>>> You work has NOTHING to do with Halting, as your H/D are not even
>>>>> turing equivalenet to their namesakes in the proof you like to
>>>>> mention.
>>>>
>>>> That is the exact verbatim post and the first respondent agreed
>>>> and immediately noticed that I was referring to the halting problem.
>>>>
>>>> So I will go with what I said, you just don't know C very
>>>> well and want to keep that hidden behind rhetoric and denigration.
>>>>
>>>>
>>>
>>>
>>> Yes, you couch it to SOUND like the halting problem, but it isn't as
>>> you have FUNDAMENTALLY CHANGED the meaning of terms.
>>>
>>> And thus, to act like it is, just makes you a LIAR.
>>>
>>> Halting is NOT about H being able to simulate it input to the final
>>> state. PERIOD.
>>>
>>
>> I could show how it is but you prefer to believe otherwise and refuse
>> to go through the detailed steps required.
>
> No, you CAN'T, because you have FUNDAMENTALLY changed the question, sinc
> eyou claim that even though D(D) Halts, that H(D,D) is correct to say
> not halting.
>

It is not my error it is your indoctrination.

>>
>> It is psychotic that people really believes that the principle of
>> explosion is valid inference even though there is zero doubt the it
>> derives the non-sequitur error.
>
> Nope, that just means you don't understand how logic works.
>
> YOU are the psychotic.
>
>>
>> *When we encode the principle of explosion as a syllogism*
>> Socrates is a man.
>> Socrates is not a man.
>> Therefore, Socrates is a butterfly.
>
> Nope. And that is because the principle of explosion is NOT a "syllogism"
>
> You are again just proving your stupidity.
>
>>
>> The conclusion does not follow from the premises, thus the
>> non-sequitur error. https://en.wikipedia.org/wiki/Principle_of_explosion
>
> So, which step doesn't is incorrect.
>
> Givens:
> Proposition A is True.
> Proposition A is False.
>

The syllogism would be dead right there.
Some A are True
No A are True

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

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

On 4/27/24 10:33 PM, olcott wrote:
> On 4/27/2024 9:09 PM, Richard Damon wrote:
>> On 4/27/24 9:54 PM, olcott wrote:
>>> On 4/27/2024 8:39 PM, Richard Damon wrote:
>>>> On 4/27/24 8:58 PM, olcott wrote:
>>>>> On 4/27/2024 7:49 PM, Richard Damon wrote:
>>>>>> On 4/27/24 8:17 PM, olcott wrote:
>>>>>>> Can D 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   D(D);
>>>>>>> 15 }
>>>>>>>
>>>>>>> Execution Trace
>>>>>>> Line 14: main() invokes 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 its own line 09.
>>>>>>>
>>>>>>> Is it dead obvious to everyone here when examining the execution
>>>>>>> trace of lines 14 and 06 above that D correctly simulated by H
>>>>>>> cannot
>>>>>>> possibly terminate normally by reaching its own line 09?
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Except that you fail to mention that you have admitted that you
>>>>>> are NOT working on the Halting Problem, despite trying to use
>>>>>> terminology similar to it, but having stipulated definition that
>>>>>> are in conflict with computaiton theory.
>>>>>>
>>>>>> Note, "keeps repeating (unless aborted)" is a misleading
>>>>>> statement, as your H will ALWAYS abort this input, and thus it
>>>>>> NEVER will "Keep repeating".
>>>>>>
>>>>>> You don't like me pointing out the problem because you prefer to
>>>>>> be able to LIE to people about what you are doing.
>>>>>>
>>>>>> You work has NOTHING to do with Halting, as your H/D are not even
>>>>>> turing equivalenet to their namesakes in the proof you like to
>>>>>> mention.
>>>>>
>>>>> That is the exact verbatim post and the first respondent agreed
>>>>> and immediately noticed that I was referring to the halting problem.
>>>>>
>>>>> So I will go with what I said, you just don't know C very
>>>>> well and want to keep that hidden behind rhetoric and denigration.
>>>>>
>>>>>
>>>>
>>>>
>>>> Yes, you couch it to SOUND like the halting problem, but it isn't as
>>>> you have FUNDAMENTALLY CHANGED the meaning of terms.
>>>>
>>>> And thus, to act like it is, just makes you a LIAR.
>>>>
>>>> Halting is NOT about H being able to simulate it input to the final
>>>> state. PERIOD.
>>>>
>>>
>>> I could show how it is but you prefer to believe otherwise and refuse
>>> to go through the detailed steps required.
>>
>> No, you CAN'T, because you have FUNDAMENTALLY changed the question,
>> sinc eyou claim that even though D(D) Halts, that H(D,D) is correct to
>> say not halting.
>>
>
> It is not my error it is your indoctrination.

So, How is H(D,D) saying false correct if D(D) Halts?

SInce the DEFINITION of the quesiton that H, the Halt Decider, is to
answer is if the computation describe by its input (that is D(D) ) will
halt when run.

You have to hide behind obfuscation, blusgter and LIES.

Since you don't seem to know that actual meaning of the words you use,
as you have even occationally admitted, it is clear who knows what they
are talking about and who doesn't.

I will also point out that you have effectively admitted that your
statements are unsopported as you always fail to provide actual
references to accepted ground for your claims.

>
>>>
>>> It is psychotic that people really believes that the principle of
>>> explosion is valid inference even though there is zero doubt the it
>>> derives the non-sequitur error.
>>
>> Nope, that just means you don't understand how logic works.
>>
>> YOU are the psychotic.
>>
>>>
>>> *When we encode the principle of explosion as a syllogism*
>>> Socrates is a man.
>>> Socrates is not a man.
>>> Therefore, Socrates is a butterfly.
>>
>> Nope. And that is because the principle of explosion is NOT a "syllogism"
>>
>> You are again just proving your stupidity.
>>
>>>
>>> The conclusion does not follow from the premises, thus the
>>> non-sequitur error. https://en.wikipedia.org/wiki/Principle_of_explosion
>>
>> So, which step doesn't is incorrect.
>>
>> Givens:
>> Proposition A is True.
>> Proposition A is False.
>>
>
> The syllogism would be dead right there.
> Some A are True
> No A are True

So, you don't understand what the principle of explosion actually is.

Remember, the principle of explsion states (in one form) that if a
system can show a contradiction (i.e. has a proposition A that can be
shown to be both True or False) then, in that system, you can prove any
other statement in the system (and its inverse which would also be a
statement in the system).

Why do you think we need to go to the lower level of just categorical logic?

Note, "Socrates is a man" would not normally be converted into the
expression "Some Socrates are Men"

Part of the issue is that a "Syllogism", as a logical form, is less
powerful than the full logic system, as it is restricted to categorical
logic, while the principle of explosion is NOT restricted to such a
logic system.

Note, this is part of your problem as the Syllogism form can't really
express the Principle of Explosion, but categorical logic is subject to
it, as it allows for use of simple logic on the categories.

For example:

Givens:

Some A are B
No A are B

Show:
Some C are D

1) We have from 1st given: Some A are B is True.
2) If statement x is true, then the statement x | y must be true.
3) Thus the statement Some A are B or some C are D must be true
4) If the statement x | y is true, but x is not true, then y must be true.
5) from the second given: No A are B
6) This can be inverted to; It is false that some A are B
7) Combine with 3) Some A are B or Some C are D must to true
8) Yields that Some C are D must be true.

What is the error in that logic?

On 4/27/2024 10:31 PM, Richard Damon wrote:
> On 4/27/24 10:33 PM, olcott wrote:
>> On 4/27/2024 9:09 PM, Richard Damon wrote:
>>> On 4/27/24 9:54 PM, olcott wrote:
>>>> On 4/27/2024 8:39 PM, Richard Damon wrote:
>>>>> On 4/27/24 8:58 PM, olcott wrote:
>>>>>> On 4/27/2024 7:49 PM, Richard Damon wrote:
>>>>>>> On 4/27/24 8:17 PM, olcott wrote:
>>>>>>>> Can D 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   D(D);
>>>>>>>> 15 }
>>>>>>>>
>>>>>>>> Execution Trace
>>>>>>>> Line 14: main() invokes 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 its own line 09.
>>>>>>>>
>>>>>>>> Is it dead obvious to everyone here when examining the execution
>>>>>>>> trace of lines 14 and 06 above that D correctly simulated by H
>>>>>>>> cannot
>>>>>>>> possibly terminate normally by reaching its own line 09?
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Except that you fail to mention that you have admitted that you
>>>>>>> are NOT working on the Halting Problem, despite trying to use
>>>>>>> terminology similar to it, but having stipulated definition that
>>>>>>> are in conflict with computaiton theory.
>>>>>>>
>>>>>>> Note, "keeps repeating (unless aborted)" is a misleading
>>>>>>> statement, as your H will ALWAYS abort this input, and thus it
>>>>>>> NEVER will "Keep repeating".
>>>>>>>
>>>>>>> You don't like me pointing out the problem because you prefer to
>>>>>>> be able to LIE to people about what you are doing.
>>>>>>>
>>>>>>> You work has NOTHING to do with Halting, as your H/D are not even
>>>>>>> turing equivalenet to their namesakes in the proof you like to
>>>>>>> mention.
>>>>>>
>>>>>> That is the exact verbatim post and the first respondent agreed
>>>>>> and immediately noticed that I was referring to the halting problem.
>>>>>>
>>>>>> So I will go with what I said, you just don't know C very
>>>>>> well and want to keep that hidden behind rhetoric and denigration.
>>>>>>
>>>>>>
>>>>>
>>>>>
>>>>> Yes, you couch it to SOUND like the halting problem, but it isn't
>>>>> as you have FUNDAMENTALLY CHANGED the meaning of terms.
>>>>>
>>>>> And thus, to act like it is, just makes you a LIAR.
>>>>>
>>>>> Halting is NOT about H being able to simulate it input to the final
>>>>> state. PERIOD.
>>>>>
>>>>
>>>> I could show how it is but you prefer to believe otherwise and refuse
>>>> to go through the detailed steps required.
>>>
>>> No, you CAN'T, because you have FUNDAMENTALLY changed the question,
>>> sinc eyou claim that even though D(D) Halts, that H(D,D) is correct
>>> to say not halting.
>>>
>>
>> It is not my error it is your indoctrination.
>
> So, How is H(D,D) saying false correct if D(D) Halts?
>

You refuse to go through the mandatory steps.

> SInce the DEFINITION of the quesiton that H, the Halt Decider, is to
> answer is if the computation describe by its input (that is D(D) ) will
> halt when run.
>
> You have to hide behind obfuscation, blusgter and LIES.
>
> Since you don't seem to know that actual meaning of the words you use,
> as you have even occationally admitted, it is clear who knows what they
> are talking about and who doesn't.
>
> I will also point out that you have effectively admitted that your
> statements are unsopported as you always fail to provide actual
> references to accepted ground for your claims.
>
>
>
>
>>
>>>>
>>>> It is psychotic that people really believes that the principle of
>>>> explosion is valid inference even though there is zero doubt the it
>>>> derives the non-sequitur error.
>>>
>>> Nope, that just means you don't understand how logic works.
>>>
>>> YOU are the psychotic.
>>>
>>>>
>>>> *When we encode the principle of explosion as a syllogism*
>>>> Socrates is a man.
>>>> Socrates is not a man.
>>>> Therefore, Socrates is a butterfly.
>>>
>>> Nope. And that is because the principle of explosion is NOT a
>>> "syllogism"
>>>
>>> You are again just proving your stupidity.
>>>
>>>>
>>>> The conclusion does not follow from the premises, thus the
>>>> non-sequitur error.
>>>> https://en.wikipedia.org/wiki/Principle_of_explosion
>>>
>>> So, which step doesn't is incorrect.
>>>
>>> Givens:
>>> Proposition A is True.
>>> Proposition A is False.
>>>
>>
>> The syllogism would be dead right there.
>> Some A are True
>> No A are True
>
> So, you don't understand what the principle of explosion actually is.
>

Some A are True
No A are True
therefore B

It is categorically impossible to show:
(a) How the above two categorical propositions entail B
(b) That the above two categorical propositions are not isomorphic to POE.

You are simply indoctrinated at your core.

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

On 2024-04-28 00:17:48 +0000, olcott said:

> Can D simulated by H terminate normally?

One should not that "D simulated by H" is not the same as
"simulation of D by H". The message below seems to be more
about the latter than the former. In any case, it is more
about the properties of H than about the properties of D.

> 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 D(D);
> 15 }
>
> Execution Trace
> Line 14: main() invokes 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 its own line 09.
>
> Is it dead obvious to everyone here when examining the execution
> trace of lines 14 and 06 above that D correctly simulated by H cannot
> possibly terminate normally by reaching its own line 09?

--
Mikko

On 2024-04-28 01:54:23 +0000, olcott said:

> It is psychotic that people really believes that the principle of
> explosion is valid inference even though there is zero doubt the it
> derives the non-sequitur error.

From a false proposistion everthing follows so there is no
non-sequitur error. Instead, inference from a false propsition
is unsound. Although an unsound inference is not an error,
using the result as if were soundly proven is.

--
Mikko

On 4/28/2024 3:23 AM, Mikko wrote:
> On 2024-04-28 00:17:48 +0000, olcott said:
>
>> Can D simulated by H terminate normally?
>
> One should not that "D simulated by H" is not the same as
> "simulation of D by H". The message below seems to be more
> about the latter than the former. In any case, it is more
> about the properties of H than about the properties of D.
>

D specifies what is essentially infinite recursion to H.
Several people agreed that D simulated by H cannot possibly
reach past its own line 03 no matter what H does.

>> 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   D(D);
>> 15 }
>>
>> Execution Trace
>> Line 14: main() invokes 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 its own line 09.
>>
>> Is it dead obvious to everyone here when examining the execution
>> trace of lines 14 and 06 above that D correctly simulated by H cannot
>> possibly terminate normally by reaching its own line 09?
>
>

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

On 4/28/2024 3:30 AM, Mikko wrote:
> On 2024-04-28 01:54:23 +0000, olcott said:
>
>> It is psychotic that people really believes that the principle of
>> explosion is valid inference even though there is zero doubt the it
>> derives the non-sequitur error.
>
> From a false proposistion everthing follows so there is no
> non-sequitur error. Instead, inference from a false propsition
> is unsound. Although an unsound inference is not an error,
> using the result as if were soundly proven is.
>

It seems that far more people are indoctrinated into dogma
than can correctly apply correct reasoning:

Proposition A is True.
Proposition A is False.
Therefore B

Translated into a syllogism:

All A are True
No A are True
Therefore B

*It is categorically impossible to show*
(a) How the above two categorical propositions entail B.
(b) That the above syllogism is not isomorphic to POE.
https://en.wikipedia.org/wiki/Categorical_proposition

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

On 4/27/24 11:45 PM, olcott wrote:
> On 4/27/2024 10:31 PM, Richard Damon wrote:
>> On 4/27/24 10:33 PM, olcott wrote:
>>> On 4/27/2024 9:09 PM, Richard Damon wrote:
>>>> On 4/27/24 9:54 PM, olcott wrote:
>>>>> On 4/27/2024 8:39 PM, Richard Damon wrote:
>>>>>> On 4/27/24 8:58 PM, olcott wrote:
>>>>>>> On 4/27/2024 7:49 PM, Richard Damon wrote:
>>>>>>>> On 4/27/24 8:17 PM, olcott wrote:
>>>>>>>>> Can D 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   D(D);
>>>>>>>>> 15 }
>>>>>>>>>
>>>>>>>>> Execution Trace
>>>>>>>>> Line 14: main() invokes 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 its own line 09.
>>>>>>>>>
>>>>>>>>> Is it dead obvious to everyone here when examining the execution
>>>>>>>>> trace of lines 14 and 06 above that D correctly simulated by H
>>>>>>>>> cannot
>>>>>>>>> possibly terminate normally by reaching its own line 09?
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Except that you fail to mention that you have admitted that you
>>>>>>>> are NOT working on the Halting Problem, despite trying to use
>>>>>>>> terminology similar to it, but having stipulated definition that
>>>>>>>> are in conflict with computaiton theory.
>>>>>>>>
>>>>>>>> Note, "keeps repeating (unless aborted)" is a misleading
>>>>>>>> statement, as your H will ALWAYS abort this input, and thus it
>>>>>>>> NEVER will "Keep repeating".
>>>>>>>>
>>>>>>>> You don't like me pointing out the problem because you prefer to
>>>>>>>> be able to LIE to people about what you are doing.
>>>>>>>>
>>>>>>>> You work has NOTHING to do with Halting, as your H/D are not
>>>>>>>> even turing equivalenet to their namesakes in the proof you like
>>>>>>>> to mention.
>>>>>>>
>>>>>>> That is the exact verbatim post and the first respondent agreed
>>>>>>> and immediately noticed that I was referring to the halting problem.
>>>>>>>
>>>>>>> So I will go with what I said, you just don't know C very
>>>>>>> well and want to keep that hidden behind rhetoric and denigration.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>>
>>>>>> Yes, you couch it to SOUND like the halting problem, but it isn't
>>>>>> as you have FUNDAMENTALLY CHANGED the meaning of terms.
>>>>>>
>>>>>> And thus, to act like it is, just makes you a LIAR.
>>>>>>
>>>>>> Halting is NOT about H being able to simulate it input to the
>>>>>> final state. PERIOD.
>>>>>>
>>>>>
>>>>> I could show how it is but you prefer to believe otherwise and refuse
>>>>> to go through the detailed steps required.
>>>>
>>>> No, you CAN'T, because you have FUNDAMENTALLY changed the question,
>>>> sinc eyou claim that even though D(D) Halts, that H(D,D) is correct
>>>> to say not halting.
>>>>
>>>
>>> It is not my error it is your indoctrination.
>>
>> So, How is H(D,D) saying false correct if D(D) Halts?
>>
>
> You refuse to go through the mandatory steps.

YOU are the only one that says they are "Manditory".

That doesn't make them so for me.

YOU refuse to explain how a Halting Turing Machine can be correctly
decider as "Non-Halting".

Your "excuses" all seem to boil down to you just need to lie about what
you are actually doing and that you refuse to even learn what the actual
rules and language of what you are saying you are doing are.

>
>> SInce the DEFINITION of the quesiton that H, the Halt Decider, is to
>> answer is if the computation describe by its input (that is D(D) )
>> will halt when run.
>>
>> You have to hide behind obfuscation, blusgter and LIES.
>>
>> Since you don't seem to know that actual meaning of the words you use,
>> as you have even occationally admitted, it is clear who knows what
>> they are talking about and who doesn't.
>>
>> I will also point out that you have effectively admitted that your
>> statements are unsopported as you always fail to provide actual
>> references to accepted ground for your claims.
>>
>>
>>
>>
>>>
>>>>>
>>>>> It is psychotic that people really believes that the principle of
>>>>> explosion is valid inference even though there is zero doubt the it
>>>>> derives the non-sequitur error.
>>>>
>>>> Nope, that just means you don't understand how logic works.
>>>>
>>>> YOU are the psychotic.
>>>>
>>>>>
>>>>> *When we encode the principle of explosion as a syllogism*
>>>>> Socrates is a man.
>>>>> Socrates is not a man.
>>>>> Therefore, Socrates is a butterfly.
>>>>
>>>> Nope. And that is because the principle of explosion is NOT a
>>>> "syllogism"
>>>>
>>>> You are again just proving your stupidity.
>>>>
>>>>>
>>>>> The conclusion does not follow from the premises, thus the
>>>>> non-sequitur error.
>>>>> https://en.wikipedia.org/wiki/Principle_of_explosion
>>>>
>>>> So, which step doesn't is incorrect.
>>>>
>>>> Givens:
>>>> Proposition A is True.
>>>> Proposition A is False.
>>>>
>>>
>>> The syllogism would be dead right there.
>>> Some A are True
>>> No A are True
>>
>> So, you don't understand what the principle of explosion actually is.
>>
>
> Some A are True
> No A are True
> therefore B

Which was proven.

And you are admitting the proof is correct, as you show you need to hide
it by trimming, as you can't find an error in it.

Thus, it seems the essential nature of your "Correct Reasoning" is that
you are allowed to ignore statements that have been proven that you do
not like the results, just as it seems you are allowed to assume
statements you can not prove to be actually true.

On 4/28/24 9:06 AM, olcott wrote:
> On 4/28/2024 3:30 AM, Mikko wrote:
>> On 2024-04-28 01:54:23 +0000, olcott said:
>>
>>> It is psychotic that people really believes that the principle of
>>> explosion is valid inference even though there is zero doubt the it
>>> derives the non-sequitur error.
>>
>>  From a false proposistion everthing follows so there is no
>> non-sequitur error. Instead, inference from a false propsition
>> is unsound. Although an unsound inference is not an error,
>> using the result as if were soundly proven is.
>>
>
> It seems that far more people are indoctrinated into dogma
> than can correctly apply correct reasoning:
>
> Proposition A is True.
> Proposition A is False.
> Therefore B
>
> Translated into a syllogism:
>
> All A are True
>  No A are True
> Therefore B
>
> *It is categorically impossible to show*
> (a) How the above two categorical propositions entail B.
> (b) That the above syllogism is not isomorphic to POE.
> https://en.wikipedia.org/wiki/Categorical_proposition
>

Then what was wrong with the proof I gave.

It is hard to convincingly say something is impossible to show, when it
has been.

That just makes you look totally stupid, which you have proven time and
time again that you are.

On 4/28/24 8:56 AM, olcott wrote:
> On 4/28/2024 3:23 AM, Mikko wrote:
>> On 2024-04-28 00:17:48 +0000, olcott said:
>>
>>> Can D simulated by H terminate normally?
>>
>> One should not that "D simulated by H" is not the same as
>> "simulation of D by H". The message below seems to be more
>> about the latter than the former. In any case, it is more
>> about the properties of H than about the properties of D.
>>
>
> D specifies what is essentially infinite recursion to H.
> Several people agreed that D simulated by H cannot possibly
> reach past its own line 03 no matter what H does.

Nope, it is only that if H fails to be a decider.

Since you claim H to be a decider, D can not have infinite recursion,
because H must return in finite time.

Yes, we get two different, and contradictory, sets of results depending
on which facts we look at. The cause of this is the principle of
explosion, that somewhere in our setup we have a false premise, and that
turns out to be that there can exist an H that can correctly determine
the halting status of its input, or in particular, the input built by
this formula.

>
>>> 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   D(D);
>>> 15 }
>>>
>>> Execution Trace
>>> Line 14: main() invokes 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 its own line 09.
>>>
>>> Is it dead obvious to everyone here when examining the execution
>>> trace of lines 14 and 06 above that D correctly simulated by H cannot
>>> possibly terminate normally by reaching its own line 09?
>>
>>
>

On 4/28/2024 8:13 AM, Richard Damon wrote:
> On 4/27/24 11:45 PM, olcott wrote:
>> On 4/27/2024 10:31 PM, Richard Damon wrote:
>>> On 4/27/24 10:33 PM, olcott wrote:
>>>> On 4/27/2024 9:09 PM, Richard Damon wrote:
>>>>> On 4/27/24 9:54 PM, olcott wrote:
>>>>>> On 4/27/2024 8:39 PM, Richard Damon wrote:
>>>>>>> On 4/27/24 8:58 PM, olcott wrote:
>>>>>>>> On 4/27/2024 7:49 PM, Richard Damon wrote:
>>>>>>>>> On 4/27/24 8:17 PM, olcott wrote:
>>>>>>>>>> Can D 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   D(D);
>>>>>>>>>> 15 }
>>>>>>>>>>
>>>>>>>>>> Execution Trace
>>>>>>>>>> Line 14: main() invokes 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 its own line 09.
>>>>>>>>>>
>>>>>>>>>> Is it dead obvious to everyone here when examining the execution
>>>>>>>>>> trace of lines 14 and 06 above that D correctly simulated by H
>>>>>>>>>> cannot
>>>>>>>>>> possibly terminate normally by reaching its own line 09?
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Except that you fail to mention that you have admitted that you
>>>>>>>>> are NOT working on the Halting Problem, despite trying to use
>>>>>>>>> terminology similar to it, but having stipulated definition
>>>>>>>>> that are in conflict with computaiton theory.
>>>>>>>>>
>>>>>>>>> Note, "keeps repeating (unless aborted)" is a misleading
>>>>>>>>> statement, as your H will ALWAYS abort this input, and thus it
>>>>>>>>> NEVER will "Keep repeating".
>>>>>>>>>
>>>>>>>>> You don't like me pointing out the problem because you prefer
>>>>>>>>> to be able to LIE to people about what you are doing.
>>>>>>>>>
>>>>>>>>> You work has NOTHING to do with Halting, as your H/D are not
>>>>>>>>> even turing equivalenet to their namesakes in the proof you
>>>>>>>>> like to mention.
>>>>>>>>
>>>>>>>> That is the exact verbatim post and the first respondent agreed
>>>>>>>> and immediately noticed that I was referring to the halting
>>>>>>>> problem.
>>>>>>>>
>>>>>>>> So I will go with what I said, you just don't know C very
>>>>>>>> well and want to keep that hidden behind rhetoric and denigration.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> Yes, you couch it to SOUND like the halting problem, but it isn't
>>>>>>> as you have FUNDAMENTALLY CHANGED the meaning of terms.
>>>>>>>
>>>>>>> And thus, to act like it is, just makes you a LIAR.
>>>>>>>
>>>>>>> Halting is NOT about H being able to simulate it input to the
>>>>>>> final state. PERIOD.
>>>>>>>
>>>>>>
>>>>>> I could show how it is but you prefer to believe otherwise and refuse
>>>>>> to go through the detailed steps required.
>>>>>
>>>>> No, you CAN'T, because you have FUNDAMENTALLY changed the question,
>>>>> sinc eyou claim that even though D(D) Halts, that H(D,D) is correct
>>>>> to say not halting.
>>>>>
>>>>
>>>> It is not my error it is your indoctrination.
>>>
>>> So, How is H(D,D) saying false correct if D(D) Halts?
>>>
>>
>> You refuse to go through the mandatory steps.
>
> YOU are the only one that says they are "Manditory".
>
> That doesn't make them so for me.
>
> YOU refuse to explain how a Halting Turing Machine can be correctly
> decider as "Non-Halting".
>
> Your "excuses" all seem to boil down to you just need to lie about what
> you are actually doing and that you refuse to even learn what the actual
> rules and language of what you are saying you are doing are.
>
>>
>>> SInce the DEFINITION of the quesiton that H, the Halt Decider, is to
>>> answer is if the computation describe by its input (that is D(D) )
>>> will halt when run.
>>>
>>> You have to hide behind obfuscation, blusgter and LIES.
>>>
>>> Since you don't seem to know that actual meaning of the words you
>>> use, as you have even occationally admitted, it is clear who knows
>>> what they are talking about and who doesn't.
>>>
>>> I will also point out that you have effectively admitted that your
>>> statements are unsopported as you always fail to provide actual
>>> references to accepted ground for your claims.
>>>
>>>
>>>
>>>
>>>>
>>>>>>
>>>>>> It is psychotic that people really believes that the principle of
>>>>>> explosion is valid inference even though there is zero doubt the it
>>>>>> derives the non-sequitur error.
>>>>>
>>>>> Nope, that just means you don't understand how logic works.
>>>>>
>>>>> YOU are the psychotic.
>>>>>
>>>>>>
>>>>>> *When we encode the principle of explosion as a syllogism*
>>>>>> Socrates is a man.
>>>>>> Socrates is not a man.
>>>>>> Therefore, Socrates is a butterfly.
>>>>>
>>>>> Nope. And that is because the principle of explosion is NOT a
>>>>> "syllogism"
>>>>>
>>>>> You are again just proving your stupidity.
>>>>>
>>>>>>
>>>>>> The conclusion does not follow from the premises, thus the
>>>>>> non-sequitur error.
>>>>>> https://en.wikipedia.org/wiki/Principle_of_explosion
>>>>>
>>>>> So, which step doesn't is incorrect.
>>>>>
>>>>> Givens:
>>>>> Proposition A is True.
>>>>> Proposition A is False.
>>>>>
>>>>
>>>> The syllogism would be dead right there.
>>>> Some A are True
>>>> No A are True
>>>
>>> So, you don't understand what the principle of explosion actually is.
>>>
>>
>> Some A are True
>> No A are True
>> therefore B
>
> Which was proven.
>

On 4/28/2024 8:19 AM, Richard Damon wrote:
> On 4/28/24 8:56 AM, olcott wrote:
>> On 4/28/2024 3:23 AM, Mikko wrote:
>>> On 2024-04-28 00:17:48 +0000, olcott said:
>>>
>>>> Can D simulated by H terminate normally?
>>>
>>> One should not that "D simulated by H" is not the same as
>>> "simulation of D by H". The message below seems to be more
>>> about the latter than the former. In any case, it is more
>>> about the properties of H than about the properties of D.
>>>
>>
>> D specifies what is essentially infinite recursion to H.
>> Several people agreed that D simulated by H cannot possibly
>> reach past its own line 03 no matter what H does.
>
> Nope, it is only that if H fails to be a decider.
>

*We don't make this leap of logic. I never used the term decider*
*We don't make this leap of logic. I never used the term decider*
*We don't make this leap of logic. I never used the term decider*
*We don't make this leap of logic. I never used the term decider*

We are only concerned with the behavior of a pair of C functions.
Unless I require that reviewers proceed through every slight nuance
of details of my reasoning they simply ignore my words and leap to
the conclusion that I must be wrong.

*It will be increasingly more clear that your rebuttals are baseless*
*It will be increasingly more clear that your rebuttals are baseless*
*It will be increasingly more clear that your rebuttals are baseless*

> Since you claim H to be a decider, D can not have infinite recursion,
> because H must return in finite time.
>
> Yes, we get two different, and contradictory, sets of results depending
> on which facts we look at. The cause of this is the principle of
> explosion, that somewhere in our setup we have a false premise, and that
> turns out to be that there can exist an H that can correctly determine
> the halting status of its input, or in particular, the input built by
> this formula.
>
>>
>>>> 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   D(D);
>>>> 15 }
>>>>
>>>> Execution Trace
>>>> Line 14: main() invokes 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 its own line 09.
>>>>
>>>> Is it dead obvious to everyone here when examining the execution
>>>> trace of lines 14 and 06 above that D correctly simulated by H cannot
>>>> possibly terminate normally by reaching its own line 09?
>>>
>>>
>>
>

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

On 4/28/24 9:45 AM, olcott wrote:
> On 4/28/2024 8:13 AM, Richard Damon wrote:
>> On 4/27/24 11:45 PM, olcott wrote:
>>> On 4/27/2024 10:31 PM, Richard Damon wrote:
>>>> On 4/27/24 10:33 PM, olcott wrote:
>>>>> On 4/27/2024 9:09 PM, Richard Damon wrote:
>>>>>> On 4/27/24 9:54 PM, olcott wrote:
>>>>>>> On 4/27/2024 8:39 PM, Richard Damon wrote:
>>>>>>>> On 4/27/24 8:58 PM, olcott wrote:
>>>>>>>>> On 4/27/2024 7:49 PM, Richard Damon wrote:
>>>>>>>>>> On 4/27/24 8:17 PM, olcott wrote:
>>>>>>>>>>> Can D 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   D(D);
>>>>>>>>>>> 15 }
>>>>>>>>>>>
>>>>>>>>>>> Execution Trace
>>>>>>>>>>> Line 14: main() invokes 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 its own line
>>>>>>>>>>> 09.
>>>>>>>>>>>
>>>>>>>>>>> Is it dead obvious to everyone here when examining the execution
>>>>>>>>>>> trace of lines 14 and 06 above that D correctly simulated by
>>>>>>>>>>> H cannot
>>>>>>>>>>> possibly terminate normally by reaching its own line 09?
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Except that you fail to mention that you have admitted that
>>>>>>>>>> you are NOT working on the Halting Problem, despite trying to
>>>>>>>>>> use terminology similar to it, but having stipulated
>>>>>>>>>> definition that are in conflict with computaiton theory.
>>>>>>>>>>
>>>>>>>>>> Note, "keeps repeating (unless aborted)" is a misleading
>>>>>>>>>> statement, as your H will ALWAYS abort this input, and thus it
>>>>>>>>>> NEVER will "Keep repeating".
>>>>>>>>>>
>>>>>>>>>> You don't like me pointing out the problem because you prefer
>>>>>>>>>> to be able to LIE to people about what you are doing.
>>>>>>>>>>
>>>>>>>>>> You work has NOTHING to do with Halting, as your H/D are not
>>>>>>>>>> even turing equivalenet to their namesakes in the proof you
>>>>>>>>>> like to mention.
>>>>>>>>>
>>>>>>>>> That is the exact verbatim post and the first respondent agreed
>>>>>>>>> and immediately noticed that I was referring to the halting
>>>>>>>>> problem.
>>>>>>>>>
>>>>>>>>> So I will go with what I said, you just don't know C very
>>>>>>>>> well and want to keep that hidden behind rhetoric and denigration.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> Yes, you couch it to SOUND like the halting problem, but it
>>>>>>>> isn't as you have FUNDAMENTALLY CHANGED the meaning of terms.
>>>>>>>>
>>>>>>>> And thus, to act like it is, just makes you a LIAR.
>>>>>>>>
>>>>>>>> Halting is NOT about H being able to simulate it input to the
>>>>>>>> final state. PERIOD.
>>>>>>>>
>>>>>>>
>>>>>>> I could show how it is but you prefer to believe otherwise and
>>>>>>> refuse
>>>>>>> to go through the detailed steps required.
>>>>>>
>>>>>> No, you CAN'T, because you have FUNDAMENTALLY changed the
>>>>>> question, sinc eyou claim that even though D(D) Halts, that H(D,D)
>>>>>> is correct to say not halting.
>>>>>>
>>>>>
>>>>> It is not my error it is your indoctrination.
>>>>
>>>> So, How is H(D,D) saying false correct if D(D) Halts?
>>>>
>>>
>>> You refuse to go through the mandatory steps.
>>
>> YOU are the only one that says they are "Manditory".
>>
>> That doesn't make them so for me.
>>
>> YOU refuse to explain how a Halting Turing Machine can be correctly
>> decider as "Non-Halting".
>>
>> Your "excuses" all seem to boil down to you just need to lie about
>> what you are actually doing and that you refuse to even learn what the
>> actual rules and language of what you are saying you are doing are.
>>
>>>
>>>> SInce the DEFINITION of the quesiton that H, the Halt Decider, is to
>>>> answer is if the computation describe by its input (that is D(D) )
>>>> will halt when run.
>>>>
>>>> You have to hide behind obfuscation, blusgter and LIES.
>>>>
>>>> Since you don't seem to know that actual meaning of the words you
>>>> use, as you have even occationally admitted, it is clear who knows
>>>> what they are talking about and who doesn't.
>>>>
>>>> I will also point out that you have effectively admitted that your
>>>> statements are unsopported as you always fail to provide actual
>>>> references to accepted ground for your claims.
>>>>
>>>>
>>>>
>>>>
>>>>>
>>>>>>>
>>>>>>> It is psychotic that people really believes that the principle of
>>>>>>> explosion is valid inference even though there is zero doubt the it
>>>>>>> derives the non-sequitur error.
>>>>>>
>>>>>> Nope, that just means you don't understand how logic works.
>>>>>>
>>>>>> YOU are the psychotic.
>>>>>>
>>>>>>>
>>>>>>> *When we encode the principle of explosion as a syllogism*
>>>>>>> Socrates is a man.
>>>>>>> Socrates is not a man.
>>>>>>> Therefore, Socrates is a butterfly.
>>>>>>
>>>>>> Nope. And that is because the principle of explosion is NOT a
>>>>>> "syllogism"
>>>>>>
>>>>>> You are again just proving your stupidity.
>>>>>>
>>>>>>>
>>>>>>> The conclusion does not follow from the premises, thus the
>>>>>>> non-sequitur error.
>>>>>>> https://en.wikipedia.org/wiki/Principle_of_explosion
>>>>>>
>>>>>> So, which step doesn't is incorrect.
>>>>>>
>>>>>> Givens:
>>>>>> Proposition A is True.
>>>>>> Proposition A is False.
>>>>>>
>>>>>
>>>>> The syllogism would be dead right there.
>>>>> Some A are True
>>>>> No A are True
>>>>
>>>> So, you don't understand what the principle of explosion actually is.
>>>>
>>>
>>> Some A are True
>>> No A are True
>>> therefore B
>>
>> Which was proven.
>>
>
> You are indoctrinated into believing that the non-sequitur error
> is not an error. The only semantics that passes out of (A ∧ ~A)
> is FALSE.

On 4/28/2024 9:00 AM, Richard Damon wrote:
> On 4/28/24 9:45 AM, olcott wrote:
>> On 4/28/2024 8:13 AM, Richard Damon wrote:
>>> On 4/27/24 11:45 PM, olcott wrote:
>>>> On 4/27/2024 10:31 PM, Richard Damon wrote:
>>>>> On 4/27/24 10:33 PM, olcott wrote:
>>>>>> On 4/27/2024 9:09 PM, Richard Damon wrote:
>>>>>>> On 4/27/24 9:54 PM, olcott wrote:
>>>>>>>> On 4/27/2024 8:39 PM, Richard Damon wrote:
>>>>>>>>> On 4/27/24 8:58 PM, olcott wrote:
>>>>>>>>>> On 4/27/2024 7:49 PM, Richard Damon wrote:
>>>>>>>>>>> On 4/27/24 8:17 PM, olcott wrote:
>>>>>>>>>>>> Can D 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   D(D);
>>>>>>>>>>>> 15 }
>>>>>>>>>>>>
>>>>>>>>>>>> Execution Trace
>>>>>>>>>>>> Line 14: main() invokes 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 its own
>>>>>>>>>>>> line 09.
>>>>>>>>>>>>
>>>>>>>>>>>> Is it dead obvious to everyone here when examining the
>>>>>>>>>>>> execution
>>>>>>>>>>>> trace of lines 14 and 06 above that D correctly simulated by
>>>>>>>>>>>> H cannot
>>>>>>>>>>>> possibly terminate normally by reaching its own line 09?
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Except that you fail to mention that you have admitted that
>>>>>>>>>>> you are NOT working on the Halting Problem, despite trying to
>>>>>>>>>>> use terminology similar to it, but having stipulated
>>>>>>>>>>> definition that are in conflict with computaiton theory.
>>>>>>>>>>>
>>>>>>>>>>> Note, "keeps repeating (unless aborted)" is a misleading
>>>>>>>>>>> statement, as your H will ALWAYS abort this input, and thus
>>>>>>>>>>> it NEVER will "Keep repeating".
>>>>>>>>>>>
>>>>>>>>>>> You don't like me pointing out the problem because you prefer
>>>>>>>>>>> to be able to LIE to people about what you are doing.
>>>>>>>>>>>
>>>>>>>>>>> You work has NOTHING to do with Halting, as your H/D are not
>>>>>>>>>>> even turing equivalenet to their namesakes in the proof you
>>>>>>>>>>> like to mention.
>>>>>>>>>>
>>>>>>>>>> That is the exact verbatim post and the first respondent agreed
>>>>>>>>>> and immediately noticed that I was referring to the halting
>>>>>>>>>> problem.
>>>>>>>>>>
>>>>>>>>>> So I will go with what I said, you just don't know C very
>>>>>>>>>> well and want to keep that hidden behind rhetoric and
>>>>>>>>>> denigration.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Yes, you couch it to SOUND like the halting problem, but it
>>>>>>>>> isn't as you have FUNDAMENTALLY CHANGED the meaning of terms.
>>>>>>>>>
>>>>>>>>> And thus, to act like it is, just makes you a LIAR.
>>>>>>>>>
>>>>>>>>> Halting is NOT about H being able to simulate it input to the
>>>>>>>>> final state. PERIOD.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I could show how it is but you prefer to believe otherwise and
>>>>>>>> refuse
>>>>>>>> to go through the detailed steps required.
>>>>>>>
>>>>>>> No, you CAN'T, because you have FUNDAMENTALLY changed the
>>>>>>> question, sinc eyou claim that even though D(D) Halts, that
>>>>>>> H(D,D) is correct to say not halting.
>>>>>>>
>>>>>>
>>>>>> It is not my error it is your indoctrination.
>>>>>
>>>>> So, How is H(D,D) saying false correct if D(D) Halts?
>>>>>
>>>>
>>>> You refuse to go through the mandatory steps.
>>>
>>> YOU are the only one that says they are "Manditory".
>>>
>>> That doesn't make them so for me.
>>>
>>> YOU refuse to explain how a Halting Turing Machine can be correctly
>>> decider as "Non-Halting".
>>>
>>> Your "excuses" all seem to boil down to you just need to lie about
>>> what you are actually doing and that you refuse to even learn what
>>> the actual rules and language of what you are saying you are doing are.
>>>
>>>>
>>>>> SInce the DEFINITION of the quesiton that H, the Halt Decider, is
>>>>> to answer is if the computation describe by its input (that is D(D)
>>>>> ) will halt when run.
>>>>>
>>>>> You have to hide behind obfuscation, blusgter and LIES.
>>>>>
>>>>> Since you don't seem to know that actual meaning of the words you
>>>>> use, as you have even occationally admitted, it is clear who knows
>>>>> what they are talking about and who doesn't.
>>>>>
>>>>> I will also point out that you have effectively admitted that your
>>>>> statements are unsopported as you always fail to provide actual
>>>>> references to accepted ground for your claims.
>>>>>
>>>>>
>>>>>
>>>>>
>>>>>>
>>>>>>>>
>>>>>>>> It is psychotic that people really believes that the principle of
>>>>>>>> explosion is valid inference even though there is zero doubt the it
>>>>>>>> derives the non-sequitur error.
>>>>>>>
>>>>>>> Nope, that just means you don't understand how logic works.
>>>>>>>
>>>>>>> YOU are the psychotic.
>>>>>>>
>>>>>>>>
>>>>>>>> *When we encode the principle of explosion as a syllogism*
>>>>>>>> Socrates is a man.
>>>>>>>> Socrates is not a man.
>>>>>>>> Therefore, Socrates is a butterfly.
>>>>>>>
>>>>>>> Nope. And that is because the principle of explosion is NOT a
>>>>>>> "syllogism"
>>>>>>>
>>>>>>> You are again just proving your stupidity.
>>>>>>>
>>>>>>>>
>>>>>>>> The conclusion does not follow from the premises, thus the
>>>>>>>> non-sequitur error.
>>>>>>>> https://en.wikipedia.org/wiki/Principle_of_explosion
>>>>>>>
>>>>>>> So, which step doesn't is incorrect.
>>>>>>>
>>>>>>> Givens:
>>>>>>> Proposition A is True.
>>>>>>> Proposition A is False.
>>>>>>>
>>>>>>
>>>>>> The syllogism would be dead right there.
>>>>>> Some A are True
>>>>>> No A are True
>>>>>
>>>>> So, you don't understand what the principle of explosion actually is.
>>>>>
>>>>
>>>> Some A are True
>>>> No A are True
>>>> therefore B
>>>
>>> Which was proven.
>>>
>>
>> You are indoctrinated into believing that the non-sequitur error
>> is not an error. The only semantics that passes out of (A ∧ ~A)
>> is FALSE.
>
> And you only get the "non-sequitur" form because The Principle of
> Explosion is not a Syllogism. It is a THEOREM.
>

On 4/28/24 9:52 AM, olcott wrote:
> On 4/28/2024 8:19 AM, Richard Damon wrote:
>> On 4/28/24 8:56 AM, olcott wrote:
>>> On 4/28/2024 3:23 AM, Mikko wrote:
>>>> On 2024-04-28 00:17:48 +0000, olcott said:
>>>>
>>>>> Can D simulated by H terminate normally?
>>>>
>>>> One should not that "D simulated by H" is not the same as
>>>> "simulation of D by H". The message below seems to be more
>>>> about the latter than the former. In any case, it is more
>>>> about the properties of H than about the properties of D.
>>>>
>>>
>>> D specifies what is essentially infinite recursion to H.
>>> Several people agreed that D simulated by H cannot possibly
>>> reach past its own line 03 no matter what H does.
>>
>> Nope, it is only that if H fails to be a decider.
>>
>
> *We don't make this leap of logic. I never used the term decider*
> *We don't make this leap of logic. I never used the term decider*
> *We don't make this leap of logic. I never used the term decider*
> *We don't make this leap of logic. I never used the term decider*

You admit that people see that as being a claim about the Halting
Problem, and thus the implied definitons of the terms apply.

This is obvious from your twenty year context of the arguement.

If you want to disconnect your recent statements from your past context,
you need to make an EXPLICIT repudiation that this is where you are
going to try to go, and that you accept that you can't just blindly
connect things back there just because of similar words.

Then, you are going to need to FORMALLY define the meaning of your words
that you are using. What are the restrictions on the "C Function" that
is trying to make the decision, and what defines "behavior"?

What are the restrictions on the "C Function" to be processed? This is
particularrly important as it appears that you allow that function to
have "unbound" references to things that are not part of it (like H).

What exactly do you men by "Simulation"? In particular, what does it
mean to correctly simulate a part of the input that isn't actually part
of the input (like the call to H)?

Then lastly, why should we care? If you can't put it into the framework
of an established problem, why should people even care about what you
are doing?

It is clear that you long term goal is to get back to the Halting
Problem and what it implies about the non-provability of some truths and
the inability to alway know if a statement is true.

You are just setting yourself up for failure, as every time you try to
move this "problem" closer to that, you are going to invalidate some of
the assumption built into your proof, and it then needs to be redone. Of
course, your idea is probably that you can get people to forget the
definitions the earlier parts were built under, after you re-stipulate
meanings over and over, and thus shouldn't be able to reach past the
definition change, but you will.

>
> We are only concerned with the behavior of a pair of C functions.
> Unless I require that reviewers proceed through every slight nuance
> of details of my reasoning they simply ignore my words and leap to
> the conclusion that I must be wrong.

Because, we know that you are, because you WILL try to link it back to
your previous claims.

You have shown that you just don't understand the meaning of the words
that you use.

>
> *It will be increasingly more clear that your rebuttals are baseless*
> *It will be increasingly more clear that your rebuttals are baseless*
> *It will be increasingly more clear that your rebuttals are baseless*

No, it is increasingly clear that you are totally ignorant of the topic
that you claimed to be working on.

It is increasingly clear that you just have no ground to base your
claims on.

If they had a base, you could start from the side next to what is
actually known and proven, and work from that side. The fact that you
can't, just means that your logic is most likely invalid.

>
>> Since you claim H to be a decider, D can not have infinite recursion,
>> because H must return in finite time.
>>
>> Yes, we get two different, and contradictory, sets of results
>> depending on which facts we look at. The cause of this is the
>> principle of explosion, that somewhere in our setup we have a false
>> premise, and that turns out to be that there can exist an H that can
>> correctly determine the halting status of its input, or in particular,
>> the input built by this formula.
>>
>>>
>>>>> 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   D(D);
>>>>> 15 }
>>>>>
>>>>> Execution Trace
>>>>> Line 14: main() invokes 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 its own line 09.
>>>>>
>>>>> Is it dead obvious to everyone here when examining the execution
>>>>> trace of lines 14 and 06 above that D correctly simulated by H cannot
>>>>> possibly terminate normally by reaching its own line 09?
>>>>
>>>>
>>>
>>
>

On 4/28/2024 10:08 AM, Richard Damon wrote:
> On 4/28/24 9:52 AM, olcott wrote:
>> On 4/28/2024 8:19 AM, Richard Damon wrote:
>>> On 4/28/24 8:56 AM, olcott wrote:
>>>> On 4/28/2024 3:23 AM, Mikko wrote:
>>>>> On 2024-04-28 00:17:48 +0000, olcott said:
>>>>>
>>>>>> Can D simulated by H terminate normally?
>>>>>
>>>>> One should not that "D simulated by H" is not the same as
>>>>> "simulation of D by H". The message below seems to be more
>>>>> about the latter than the former. In any case, it is more
>>>>> about the properties of H than about the properties of D.
>>>>>
>>>>
>>>> D specifies what is essentially infinite recursion to H.
>>>> Several people agreed that D simulated by H cannot possibly
>>>> reach past its own line 03 no matter what H does.
>>>
>>> Nope, it is only that if H fails to be a decider.
>>>
>>
>> *We don't make this leap of logic. I never used the term decider*
>> *We don't make this leap of logic. I never used the term decider*
>> *We don't make this leap of logic. I never used the term decider*
>> *We don't make this leap of logic. I never used the term decider*
>
>
> You admit that people see that as being a claim about the Halting
> Problem, and thus the implied definitons of the terms apply.
>

The only way to get people to understand that I am correct
and thus not always ignore my words and leap to the conclusion
that I must be wrong is to insist that they review every single
detail of all of my reasoning one tiny step at a time.

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

On 4/28/24 11:33 AM, olcott wrote:
> On 4/28/2024 10:08 AM, Richard Damon wrote:
>> On 4/28/24 9:52 AM, olcott wrote:
>>> On 4/28/2024 8:19 AM, Richard Damon wrote:
>>>> On 4/28/24 8:56 AM, olcott wrote:
>>>>> On 4/28/2024 3:23 AM, Mikko wrote:
>>>>>> On 2024-04-28 00:17:48 +0000, olcott said:
>>>>>>
>>>>>>> Can D simulated by H terminate normally?
>>>>>>
>>>>>> One should not that "D simulated by H" is not the same as
>>>>>> "simulation of D by H". The message below seems to be more
>>>>>> about the latter than the former. In any case, it is more
>>>>>> about the properties of H than about the properties of D.
>>>>>>
>>>>>
>>>>> D specifies what is essentially infinite recursion to H.
>>>>> Several people agreed that D simulated by H cannot possibly
>>>>> reach past its own line 03 no matter what H does.
>>>>
>>>> Nope, it is only that if H fails to be a decider.
>>>>
>>>
>>> *We don't make this leap of logic. I never used the term decider*
>>> *We don't make this leap of logic. I never used the term decider*
>>> *We don't make this leap of logic. I never used the term decider*
>>> *We don't make this leap of logic. I never used the term decider*
>>
>>
>> You admit that people see that as being a claim about the Halting
>> Problem, and thus the implied definitons of the terms apply.
>>
>
> The only way to get people to understand that I am correct
> and thus not always ignore my words and leap to the conclusion
> that I must be wrong is to insist that they review every single
> detail of all of my reasoning one tiny step at a time.
>
>

No, the way to get people to understand what you are saying is to use
the standard terminology, and start with what people will accept and
move to what is harder to understand.

People have no obligation to work in the direction you want them to.

Yes, when you speak non-sense, people will ignore you, because what you
speak is non-sense.

You are just proving that you don't understand how to perform logic, or
frame a persuasive arguement.

That fact that as far as we can tell, your "logic" is based on you
making up things and trying to form justifications for them, just makes
people unwilling to attempt to "accept" your wild ideas to see what
might make sense.

You claim you want to work in a manner to save time, but then seem to
explicitly go on a tack that will force you to waste time by needing to
return to your prior points when you change the definition and prove
them again.

Of course, the likely answer is that you DON'T plan to go back and
reshow those points, but just try to convince people that the change in
meaning between the two sides of the arguement doesn't matter.

On 4/28/24 10:15 AM, olcott wrote:
> On 4/28/2024 9:00 AM, Richard Damon wrote:
>> On 4/28/24 9:45 AM, olcott wrote:
>>> On 4/28/2024 8:13 AM, Richard Damon wrote:
>>>> On 4/27/24 11:45 PM, olcott wrote:
>>>>> On 4/27/2024 10:31 PM, Richard Damon wrote:
>>>>>> On 4/27/24 10:33 PM, olcott wrote:
>>>>>>> On 4/27/2024 9:09 PM, Richard Damon wrote:
>>>>>>>> On 4/27/24 9:54 PM, olcott wrote:
>>>>>>>>> On 4/27/2024 8:39 PM, Richard Damon wrote:
>>>>>>>>>> On 4/27/24 8:58 PM, olcott wrote:
>>>>>>>>>>> On 4/27/2024 7:49 PM, Richard Damon wrote:
>>>>>>>>>>>> On 4/27/24 8:17 PM, olcott wrote:
>>>>>>>>>>>>> Can D 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   D(D);
>>>>>>>>>>>>> 15 }
>>>>>>>>>>>>>
>>>>>>>>>>>>> Execution Trace
>>>>>>>>>>>>> Line 14: main() invokes 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 its own
>>>>>>>>>>>>> line 09.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Is it dead obvious to everyone here when examining the
>>>>>>>>>>>>> execution
>>>>>>>>>>>>> trace of lines 14 and 06 above that D correctly simulated
>>>>>>>>>>>>> by H cannot
>>>>>>>>>>>>> possibly terminate normally by reaching its own line 09?
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Except that you fail to mention that you have admitted that
>>>>>>>>>>>> you are NOT working on the Halting Problem, despite trying
>>>>>>>>>>>> to use terminology similar to it, but having stipulated
>>>>>>>>>>>> definition that are in conflict with computaiton theory.
>>>>>>>>>>>>
>>>>>>>>>>>> Note, "keeps repeating (unless aborted)" is a misleading
>>>>>>>>>>>> statement, as your H will ALWAYS abort this input, and thus
>>>>>>>>>>>> it NEVER will "Keep repeating".
>>>>>>>>>>>>
>>>>>>>>>>>> You don't like me pointing out the problem because you
>>>>>>>>>>>> prefer to be able to LIE to people about what you are doing.
>>>>>>>>>>>>
>>>>>>>>>>>> You work has NOTHING to do with Halting, as your H/D are not
>>>>>>>>>>>> even turing equivalenet to their namesakes in the proof you
>>>>>>>>>>>> like to mention.
>>>>>>>>>>>
>>>>>>>>>>> That is the exact verbatim post and the first respondent agreed
>>>>>>>>>>> and immediately noticed that I was referring to the halting
>>>>>>>>>>> problem.
>>>>>>>>>>>
>>>>>>>>>>> So I will go with what I said, you just don't know C very
>>>>>>>>>>> well and want to keep that hidden behind rhetoric and
>>>>>>>>>>> denigration.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Yes, you couch it to SOUND like the halting problem, but it
>>>>>>>>>> isn't as you have FUNDAMENTALLY CHANGED the meaning of terms.
>>>>>>>>>>
>>>>>>>>>> And thus, to act like it is, just makes you a LIAR.
>>>>>>>>>>
>>>>>>>>>> Halting is NOT about H being able to simulate it input to the
>>>>>>>>>> final state. PERIOD.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I could show how it is but you prefer to believe otherwise and
>>>>>>>>> refuse
>>>>>>>>> to go through the detailed steps required.
>>>>>>>>
>>>>>>>> No, you CAN'T, because you have FUNDAMENTALLY changed the
>>>>>>>> question, sinc eyou claim that even though D(D) Halts, that
>>>>>>>> H(D,D) is correct to say not halting.
>>>>>>>>
>>>>>>>
>>>>>>> It is not my error it is your indoctrination.
>>>>>>
>>>>>> So, How is H(D,D) saying false correct if D(D) Halts?
>>>>>>
>>>>>
>>>>> You refuse to go through the mandatory steps.
>>>>
>>>> YOU are the only one that says they are "Manditory".
>>>>
>>>> That doesn't make them so for me.
>>>>
>>>> YOU refuse to explain how a Halting Turing Machine can be correctly
>>>> decider as "Non-Halting".
>>>>
>>>> Your "excuses" all seem to boil down to you just need to lie about
>>>> what you are actually doing and that you refuse to even learn what
>>>> the actual rules and language of what you are saying you are doing are.
>>>>
>>>>>
>>>>>> SInce the DEFINITION of the quesiton that H, the Halt Decider, is
>>>>>> to answer is if the computation describe by its input (that is
>>>>>> D(D) ) will halt when run.
>>>>>>
>>>>>> You have to hide behind obfuscation, blusgter and LIES.
>>>>>>
>>>>>> Since you don't seem to know that actual meaning of the words you
>>>>>> use, as you have even occationally admitted, it is clear who knows
>>>>>> what they are talking about and who doesn't.
>>>>>>
>>>>>> I will also point out that you have effectively admitted that your
>>>>>> statements are unsopported as you always fail to provide actual
>>>>>> references to accepted ground for your claims.
>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>>>
>>>>>>>>>
>>>>>>>>> It is psychotic that people really believes that the principle of
>>>>>>>>> explosion is valid inference even though there is zero doubt
>>>>>>>>> the it
>>>>>>>>> derives the non-sequitur error.
>>>>>>>>
>>>>>>>> Nope, that just means you don't understand how logic works.
>>>>>>>>
>>>>>>>> YOU are the psychotic.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> *When we encode the principle of explosion as a syllogism*
>>>>>>>>> Socrates is a man.
>>>>>>>>> Socrates is not a man.
>>>>>>>>> Therefore, Socrates is a butterfly.
>>>>>>>>
>>>>>>>> Nope. And that is because the principle of explosion is NOT a
>>>>>>>> "syllogism"
>>>>>>>>
>>>>>>>> You are again just proving your stupidity.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> The conclusion does not follow from the premises, thus the
>>>>>>>>> non-sequitur error.
>>>>>>>>> https://en.wikipedia.org/wiki/Principle_of_explosion
>>>>>>>>
>>>>>>>> So, which step doesn't is incorrect.
>>>>>>>>
>>>>>>>> Givens:
>>>>>>>> Proposition A is True.
>>>>>>>> Proposition A is False.
>>>>>>>>
>>>>>>>
>>>>>>> The syllogism would be dead right there.
>>>>>>> Some A are True
>>>>>>> No A are True
>>>>>>
>>>>>> So, you don't understand what the principle of explosion actually is.
>>>>>>
>>>>>
>>>>> Some A are True
>>>>> No A are True
>>>>> therefore B
>>>>
>>>> Which was proven.
>>>>
>>>
>>> You are indoctrinated into believing that the non-sequitur error
>>> is not an error. The only semantics that passes out of (A ∧ ~A)
>>> is FALSE.
>>
>> And you only get the "non-sequitur" form because The Principle of
>> Explosion is not a Syllogism. It is a THEOREM.
>>
>
> All A are True
> No A are True
> Therefore B
>
> (1) Is a pair of proper categorical propositions.
>     https://en.wikipedia.org/wiki/Categorical_proposition
> (2) That are isomorphic to the Principle of Explosion.
> (3) And do form the non-sequitur error.
>

On 4/28/2024 11:08 AM, Richard Damon wrote:
> On 4/28/24 11:33 AM, olcott wrote:
>> On 4/28/2024 10:08 AM, Richard Damon wrote:
>>> On 4/28/24 9:52 AM, olcott wrote:
>>>> On 4/28/2024 8:19 AM, Richard Damon wrote:
>>>>> On 4/28/24 8:56 AM, olcott wrote:
>>>>>> On 4/28/2024 3:23 AM, Mikko wrote:
>>>>>>> On 2024-04-28 00:17:48 +0000, olcott said:
>>>>>>>
>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>
>>>>>>> One should not that "D simulated by H" is not the same as
>>>>>>> "simulation of D by H". The message below seems to be more
>>>>>>> about the latter than the former. In any case, it is more
>>>>>>> about the properties of H than about the properties of D.
>>>>>>>
>>>>>>
>>>>>> D specifies what is essentially infinite recursion to H.
>>>>>> Several people agreed that D simulated by H cannot possibly
>>>>>> reach past its own line 03 no matter what H does.
>>>>>
>>>>> Nope, it is only that if H fails to be a decider.
>>>>>
>>>>
>>>> *We don't make this leap of logic. I never used the term decider*
>>>> *We don't make this leap of logic. I never used the term decider*
>>>> *We don't make this leap of logic. I never used the term decider*
>>>> *We don't make this leap of logic. I never used the term decider*
>>>
>>>
>>> You admit that people see that as being a claim about the Halting
>>> Problem, and thus the implied definitons of the terms apply.
>>>
>>
>> The only way to get people to understand that I am correct
>> and thus not always ignore my words and leap to the conclusion
>> that I must be wrong is to insist that they review every single
>> detail of all of my reasoning one tiny step at a time.
>>
>>
>
> No, the way to get people to understand what you are saying is to use
> the standard terminology, and start with what people will accept and
> move to what is harder to understand.
>
> People have no obligation to work in the direction you want them to.
>
> Yes, when you speak non-sense, people will ignore you, because what you
> speak is non-sense.
>
> You are just proving that you don't understand how to perform logic, or
> frame a persuasive arguement.
>
> That fact that as far as we can tell, your "logic" is based on you
> making up things and trying to form justifications for them, just makes
> people unwilling to attempt to "accept" your wild ideas to see what
> might make sense.
>

Linguistic determinism is the concept that language and its structures
limit and determine human knowledge or thought, as well as thought
processes such as categorization, memory, and perception.
https://en.wikipedia.org/wiki/Linguistic_determinism

Some of the technical "terms of the art" box people into misconceptions
for which there is no escape. Some of the technical "terms of the art"
I perfectly agree with.

*Important technical "term of the art" that I totally agree with*
Computable functions are the formalized analogue of the intuitive notion
of algorithms, in the sense that a function is computable if there
exists an algorithm that can do the job of the function, i.e. given an
input of the function domain it can return the corresponding output.
https://en.wikipedia.org/wiki/Computable_function

> You claim you want to work in a manner to save time, but then seem to
> explicitly go on a tack that will force you to waste time by needing to
> return to your prior points when you change the definition and prove
> them again.
>

I am only interested in an actual honest dialogue. Because of this I
must insist that any dialogue must go through every single detail of
my reasoning one tiny nuance of a point at time.

I have spent 20 years doing this and found that this is the only
possible way to get people to actually validate my actual reasoning
and not simply ignore my words and leap to the conclusion that I
must be wrong.

We can go around and around about this until one of us gets
bored, yet I absolutely will not progress to any other points
until we have mutual agreement on the current point:

01 int D(ptr x) // ptr is pointer to int function
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 }

Simulating termination analyzer H determines whether or not
D(D) simulated by H can possibly reach its final state at its
own line 06 and halt whether or not H aborts its simulation.
https://github.com/plolcott/x86utm/blob/master/Halt7.c

(a) It is a verified fact that D(D) simulated by H cannot
possibly reach past line 03 of D(D) simulated by H whether H
aborts its simulation or not.

> Of course, the likely answer is that you DON'T plan to go back and
> reshow those points, but just try to convince people that the change in
> meaning between the two sides of the arguement doesn't matter.

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