Re: Claude.ai provides reasoning why I may have defeated the conventional HP proof

On 7/15/25 9:47 PM, olcott wrote:

On 7/15/2025 5:39 PM, Richard Damon wrote:

On 7/15/25 8:40 AM, olcott wrote:

On 7/15/2025 6:44 AM, Richard Damon wrote:

On 7/14/25 11:03 PM, olcott wrote:

On 7/14/2025 9:21 PM, Richard Damon wrote:

On 7/14/25 3:15 PM, olcott wrote:

On 7/12/2025 6:03 PM, Richard Damon wrote:

On 7/11/25 1:12 AM, olcott wrote:

On 7/10/2025 11:42 PM, André G. Isaak wrote:

On 2025-07-10 22:29, olcott wrote:

On 7/10/2025 10:58 PM, André G. Isaak wrote:

On 2025-07-10 19:58, Richard Damon wrote:

On 7/10/25 10:09 AM, olcott wrote:

>

According to the POE:
(a) The Moon is made of green cheese and
(b) the Moon does not exist
proves that
(c) Donald Trump is the Christ.

>
Rigth, but only because a side affect of (a) is that the moon must exist.

>
Really, the problem here is that Olcott fails to distinguish between the truth of a conditional statement and the truth of the consequent of a conditional statement. They are not the same thing.
>
((X & ~X) implies Y) is necessarily true.
>

>
That is not the exact meaning of these words

>
What is not the exact meaning of which words?
>

>
*This Wikipedia quote*
On 7/10/2025 11:29 PM, olcott wrote:
 >    the principle of explosion is the law according to which
 >    *any statement can be proven from a contradiction*
 > https://en.wikipedia.org/wiki/Principle_of_explosion
>
Here is the exact meaning of:
*any statement can be proven from a contradiction*
∀x (⊥ ⊢ x).
>
>
>

>
And what is wrong with the analysis given one that page:
>

André G. Isaak's paraphrase of this:
"any statement can be proven from a contradiction"
to this:
((X & ~X) implies Y) is necessarily true.
Is incorrect.
>
Here is the correct paraphrase: ∀x (⊥ ⊢ x).
>

>
And Yes that can be PROVEN
>

>
So you agree that André had this wrong when he used
implies(→) instead of proves(⊢).
>
>

>
No, The FACT that ((X & ~X) implies Y) is true is provable.
>

>
Yet is not an accurate paraphrase of: ∀x (⊥ ⊢ x)
so André was wrong in his paraphrase.

>
But ∀x (⊥ ⊢ x) isn't a correct statement of the Principle of Explosion.
>
Because it doesn't say a Falsestate proves all, it says that a contradiction proves all.
>

 Here's why falsum is important in logic
Represents contradiction: Falsum is equivalent to a contradiction like P ∧ ¬P (a statement and its negation simultaneously being true), which is always false. (Always except for nitwits that accept POE's disagreement
with the law of non-contradiction).
 

No, "falsum" is NOT equivalent to a contradiction. It can be the result of the logic processing a contradiction (when you have added the law of contradiction to your system, and thus stated that the Principle of Explosion can never be activated).
It can also be the results of just a false statement.
Your problem is you are just parrotting words without understanding where they came from.
The Principle of Explosion is ABSOULUTELY TRUE in logic system that have the minimal expressive power.
Because of that, such system just define that the conditions needed to don't occur. Note for instance, that Godel's incompleteness proof begins with the qualifications of the system it applies to, one of which is that it is not contrary, adn thus doesn't have any contradictions in it.
Your arguments are just self-recursive, and you are arguing that if a system can't have a contradiction, then the Principle of Explosion can't apply, which is actually true, but that doesn't negate the power of the principle of explosion, but shows WHY you had to make sure your system didn't have any contradictions.
Note, that is why your "input" to HHH needs to either be defined that it HAS the code for HHH as part of it, or it doesn't. There is no middle ground here.
If it doesn't have it as part of it, then no simulation of "the input" can look anywhere else to get the information (because then they aren't simulating "the input") and thus there is no correct simulation of it at all. This is why "Programs" are DEFINED to include all the code they use, and Halt Deciders work on representations of PROGRAM.
If it does contain the code for HHH, then you no longer have "the DDD", but every HHH created gets a different one, and you arguement falls apart, as all you ever do to any one particular DDD is simulate it some finite number of steps and then abort and return 0, and it can be shown that the actual correct simulation of that input will reach the final state, and thus that HHH was just wrong.
Sorry, you are just proving you are mentally incapable of handling this topic, because your mind is just filled with too many false ideas about how and why things work, because you just made them up out of your ignorance.