Re: Premises cannot be shown to be false without proving that they contradict each other

On 10/22/2024 4:50 AM, joes wrote:

Am Mon, 21 Oct 2024 22:04:49 -0500 schrieb olcott:

On 10/21/2024 9:42 PM, Richard Damon wrote:

On 10/21/24 7:08 PM, olcott wrote:

On 10/21/2024 6:05 PM, Richard Damon wrote:

On 10/21/24 6:48 PM, olcott wrote:

On 10/21/2024 5:34 PM, Richard Damon wrote:

On 10/21/24 12:29 PM, olcott wrote:

On 10/21/2024 10:17 AM, joes wrote:

Am Mon, 21 Oct 2024 08:41:11 -0500 schrieb olcott:

On 10/21/2024 3:39 AM, joes wrote:

Am Sun, 20 Oct 2024 17:36:25 -0500 schrieb olcott:

On 10/20/2024 4:41 PM, Richard Damon wrote:

On 10/20/24 4:23 PM, olcott wrote:

On 10/20/2024 2:13 PM, Richard Damon wrote:

On 10/20/24 1:33 PM, olcott wrote:

 

The executed DDD calls HHH() and this call returns. The
emulated DDD calls HHH(DDD) and this call cannot possibly
return.

But whyyy doesn't HHH abort?

You can click on the link and cut-and-paste the question to see
the whole answer in compete detail.

I am not interested in arguing with a chatbot. Make the points
yourself.
>
1. **Nature of `DDD()`**:
     - `DDD()` simply calls `HHH(DDD)`. It does not perform any
additional operations that could create a loop or prevent it from
returning.
     - If `HHH` returns (whether by aborting or completing its
simulation),
`DDD()` can return to its caller.
>
2. **Behavior of `HHH`**:
     - If `HHH` is able to simulate `DDD()` and return, it
     should
report that `DDD()` terminates. If `HHH` aborts due to detecting
non- termination,
it does not reflect the actual execution of `DDD()`; it leads to
a conclusion that may not align with the true behavior.
>
3. **Contradiction in Results**:
     - If `HHH` claims that `DDD()` does not halt, but in
     reality,
`DDD()`
can terminate once `HHH` returns, then `HHH` is providing an
incorrect analysis.
     - The contradiction lies in the ability of `HHH` to detect
     non-
termination theoretically while simultaneously allowing `DDD()`
to halt in practical execution.
>
### Conclusion:
Given the nature of `DDD()` and how `HHH` operates, it becomes
clear that `HHH` cannot consistently provide a correct answer
about whether `DDD()`
halts. The dynamics of calling and returning create a scenario
where the outcomes conflict. Thus, `HHH` is fundamentally flawed
in its role as a termination analyzer for functions like `DDD()`.

>
Did ChatGPT generate that?
If it did then I need *ALL the input that caused it to generate
that*

It's not like it will deterministically regenerate the same output.
 

No, someone using some REAL INTELEGENCE, as opposed to a program
using "artificial intelegence" that had been loaded with false
premises and other lies.

I specifically asked it to verify that its key assumption is correct
and it did.

No, it said that given what you told it (which was a lie)

I asked it if what it was told was a lie and it explained how what it
was told is correct.

"naw, I wasn't lied to, they said they were saying the truth" sure buddy.
 

Because Chat GPT doesn't care about lying.

ChatGPT computes the truth and you can't actually show otherwise.

HAHAHAHAHA there isn't anything about truth in there, prove me wrong
 

Because what you are asking for is nonsense.
Of course an AI that has been programmed with lies might repeat the
lies.
When it is told the actual definition, after being told your lies, and
asked if your conclusion could be right, it said No.
Thus, it seems by your logic, you have to admit defeat, as the AI,
after being told your lies, still was able to come up with the correct
answer, that DDD will halt, and that HHH is just incorrect to say it
doesn't.

I believe that the "output" Joes provided was fake on the basis that she
did not provide the input to derive that output and did not use the
required basis that was on the link.

I definitely typed something out in the style of an LLM instead of
my own words /s
 

If you want me to pay more attention to what you say, you first need to
return the favor, and at least TRY to find an error in what I say, and
be based on more than just that you think that can't be right.

 

But you can't do that, as you don't actually know any facts about the
field that you can point to qualified references.

You cannot show that my premises are actually false.
To show that they are false would at least require showing that they
contradict each other.

Accepting your premises makes the problem uninteresting.
 

That seems to indicate that you are admitting that you
cheated when you discussed this with ChatGPT. You gave
it a faulty basis and then argued against that.
My premises cannot be shown to be false at most they
can be shown to be unconventional.
They also conventional within the context of software
engineering. That software engineering conventions
seem incompatible with computer science conventions
may refute the latter.
The only way that ZFC resolved Russell's Paradox was that
ZFC tossed aside the conventions of
https://en.wikipedia.org/wiki/Naive_set_theory.
The a halt decider must report on the behavior that
itself is contained within seems to be an incorrect
convention.
u32 HHH1(ptr P)  // line 721
u32 HHH(ptr P)   // line 801
https://github.com/plolcott/x86utm/blob/master/Halt7.c
The above two functions have identical C code except for their name.
The input to HHH1(DDD) halts. The input to HHH(DDD) does not halt.
This conclusively proves that the pathological relationship between
DDD and HHH makes a difference in the behavior of DDD.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer