Proof of an imbecile doctrine
Posted: Mon Mar 10, 2025 6:09 am
We will analyze the following imbecile doctrine:
We now encode the imbecile doctrine in the TPTP format. The acronym "TPTP" stands for "Thousands of Problems for Theorem Provers". It is the standard format for Automated Theorem Provers:Axiomatization:
1) Mr.X Is God.
2) Mr.X is the son of God
Prove the following theorem:
Mr.X is the son of himself.
We now use the Vampire automated theorem prover to produce the proof for the imbecile conclusion:% ---------------------------------
% Imbecile doctrine in TPTP format
% ---------------------------------
% Mr.X Is God
fof(axiom1, axiom,god(MrX)).
% Mr.X is the son of God
fof(axiom2, axiom, son_of(MrX, God)).
% Imbecile conclusion. Prove that Mr.X is the son of himself.
fof(conjecture1, conjecture, son_of(MrX, MrX)).
So, we have indeed successfully proven that Mr. X is the son of himself. Why is it possible to prove this imbecile conclusion? Well, obviously, because the axioms of this doctrine are imbecile. It is an excellent example of the Garbage In, Garbage Out principle:$ ./vampire imbecile-doctrine.txt
% Running in auto input_syntax mode. Trying TPTP
% Refutation found. Thanks to Tanya!
% SZS status Theorem for imbecile-doctrine
% SZS output start Proof for imbecile-doctrine
2. son_of(X0,X1) [input]
3. son_of(X0,X0) [input]
4. ~! [X0] : son_of(X0,X0) [negated conjecture 3]
6. ! [X1,X0] : son_of(X0,X1) [closure 2]
8. ? [X0] : ~son_of(X0,X0) [ennf transformation 4]
9. ! [X0,X1] : son_of(X1,X0) [rectify 6]
10. ? [X0] : ~son_of(X0,X0) => ~son_of(sK0,sK0) [choice axiom]
11. ~son_of(sK0,sK0) [skolemisation 8,10]
12. son_of(X1,X0) [cnf transformation 9]
13. ~son_of(sK0,sK0) [cnf transformation 11]
14. $false [subsumption resolution 13,12]
% SZS output end Proof for imbecile-doctrine
Since the doctrine is pure garbage, it is obvious that its theorems will also be complete garbage. In other words, an imbecile doctrine is unusable for any practical purpose.https://en.wikipedia.org/wiki/Garbage_in,_garbage_out
In computer science, garbage in, garbage out (GIGO) is the concept that flawed, biased or poor quality ("garbage") information or input produces a result or output of similar ("garbage") quality. The adage points to the need to improve data quality in, for example, programming. Rubbish in, rubbish out (RIRO) is an alternate wording.[1][2][3]