Section Check_Proof.
Variable L : Language.
Variable codeF : Functions L -> nat.
Variable codeR : Relations L -> nat.
Variable codeArityF : nat -> nat.
Variable codeArityR : nat -> nat.
Hypothesis codeArityFIsPR : isPR 1 codeArityF.
Hypothesis
codeArityFIsCorrect1 :
forall f : Functions L, codeArityF (codeF f) = S (arity L (inr _ f)).
Hypothesis
codeArityFIsCorrect2 :
forall n : nat, codeArityF n <> 0 -> exists f : Functions L, codeF f = n.
Hypothesis codeArityRIsPR : isPR 1 codeArityR.
Hypothesis
codeArityRIsCorrect1 :
forall r : Relations L, codeArityR (codeR r) = S (arity L (inl _ r)).
Hypothesis
codeArityRIsCorrect2 :
forall n : nat, codeArityR n <> 0 -> exists r : Relations L, codeR r = n.
Hypothesis codeFInj : forall f g : Functions L, codeF f = codeF g -> f = g.
Hypothesis codeRInj : forall R S : Relations L, codeR R = codeR S -> R = S.
Let Term := Term L.
Let Terms := Terms L.
Let var := var L.
Let apply := apply L.
Let Formula := Formula L.
Let equal := equal L.
Let atomic := atomic L.
Let impH := impH L.
Let notH := notH L.
Let forallH := forallH L.
Let wellFormedTerm := wellFormedTerm codeArityF.
Let wellFormedFormula := wellFormedFormula codeArityF codeArityR.
Let Prf := Prf L.
(*The wellFormedness requirement isn't really neccesary, because and proof that used ``extra symbols'' could be turned into a proof that only used symbols from the axioms and the conclusion.  However making this assumption makes the proof easier *)
(* p is (cPair (formula) (proof of the Formula)) *)
Definition checkPrfAXM (p recs : nat) :=
switchPR (charFunction 2 beq_nat (cPairPi2 (cPairPi2 p)) (cPairPi1 p))
(S (S (cPair (cPairPi1 p) 0))) 0.

(* Specifications: *)
Lemma checkPrfAXMIsPR : isPR 2 checkPrfAXM.
Definition checkPrfMP (p recs : nat) :=
switchPR
(wellFormedFormula (cPairPi1 (cPairPi2 (cPairPi2 (cPairPi2 p)))) *
(charFunction 2 beq_nat (cPairPi1 (cPairPi1 (cPairPi2 (cPairPi2 p))))
(codeImp (cPairPi1 (cPairPi2 (cPairPi2 (cPairPi2 p)))) (cPairPi1 p)) *
(codeNth (p - S (cPairPi1 (cPairPi2 (cPairPi2 p)))) recs *
codeNth (p - S (cPairPi2 (cPairPi2 (cPairPi2 p)))) recs)))
(S
(codeApp
(pred (codeNth (p - S (cPairPi1 (cPairPi2 (cPairPi2 p)))) recs))
(pred (codeNth (p - S (cPairPi2 (cPairPi2 (cPairPi2 p)))) recs))))
0.
Lemma checkPrfMPIsPR : isPR 2 checkPrfMP.
Definition checkPrfGEN (p recs : nat) :=
switchPR
(charFunction 2 beq_nat
(cPair 3
(cPair (cPairPi1 (cPairPi2 (cPairPi2 p)))
(cPairPi1 (cPairPi2 (cPairPi2 (cPairPi2 p))))))
(cPairPi1 p) *
(codeNth (p - S (cPairPi2 (cPairPi2 (cPairPi2 p)))) recs *
(1 -
codeIn (cPairPi1 (cPairPi2 (cPairPi2 p)))
(codeFreeVarListFormula
(pred (codeNth (p - S (cPairPi2 (cPairPi2 (cPairPi2 p)))) recs))))))
(codeNth (p - S (cPairPi2 (cPairPi2 (cPairPi2 p)))) recs) 0.
Lemma checkPrfGENIsPR : isPR 2 checkPrfGEN.
Definition checkPrfIMP1 (p recs : nat) :=
let A := cPairPi1 (cPairPi2 (cPairPi2 p)) in
let B := cPairPi2 (cPairPi2 (cPairPi2 p)) in
charFunction 2 beq_nat (cPair 1 (cPair A (cPair 1 (cPair B A))))
(cPairPi1 p).
Lemma checkPrfIMP1IsPR : isPR 2 checkPrfIMP1.
Definition checkPrfIMP2 (p recs : nat) :=
let A := cPairPi1 (cPairPi2 (cPairPi2 p)) in
let B := cPairPi1 (cPairPi2 (cPairPi2 (cPairPi2 p))) in
let C := cPairPi2 (cPairPi2 (cPairPi2 (cPairPi2 p))) in
charFunction 2 beq_nat
(cPair 1
(cPair (cPair 1 (cPair A (cPair 1 (cPair B C))))
(cPair 1 (cPair (cPair 1 (cPair A B)) (cPair 1 (cPair A C))))))
(cPairPi1 p).
Lemma checkPrfIMP2IsPR : isPR 2 checkPrfIMP2.
Definition checkPrfCP (p recs : nat) :=
let A := cPairPi1 (cPairPi2 (cPairPi2 p)) in
let B := cPairPi2 (cPairPi2 (cPairPi2 p)) in
charFunction 2 beq_nat
(cPair 1
(cPair (cPair 1 (cPair (cPair 2 A) (cPair 2 B))) (cPair 1 (cPair B A))))
(cPairPi1 p).
Lemma checkPrfCPIsPR : isPR 2 checkPrfCP.
Definition checkPrfFA1 (p recs : nat) :=
let A := cPairPi1 (cPairPi2 (cPairPi2 p)) in
let v := cPairPi1 (cPairPi2 (cPairPi2 (cPairPi2 p))) in
let t := cPairPi2 (cPairPi2 (cPairPi2 (cPairPi2 p))) in
wellFormedTerm t *
charFunction 2 beq_nat
(cPair 1 (cPair (cPair 3 (cPair v A)) (codeSubFormula A v t)))
(cPairPi1 p).
Lemma checkPrfFA1IsPR : isPR 2 checkPrfFA1.
Definition checkPrfFA2 (p recs : nat) :=
let A := cPairPi1 (cPairPi2 (cPairPi2 p)) in
let v := cPairPi2 (cPairPi2 (cPairPi2 p)) in
(1 - codeIn v (codeFreeVarFormula A)) *
charFunction 2 beq_nat (cPair 1 (cPair A (cPair 3 (cPair v A))))
(cPairPi1 p).
Lemma checkPrfFA2IsPR : isPR 2 checkPrfFA2.
Definition checkPrfFA3 (p recs : nat) :=
let A := cPairPi1 (cPairPi2 (cPairPi2 p)) in
let B := cPairPi1 (cPairPi2 (cPairPi2 (cPairPi2 p))) in
let v := cPairPi2 (cPairPi2 (cPairPi2 (cPairPi2 p))) in
charFunction 2 beq_nat
(cPair 1
(cPair (cPair 3 (cPair v (cPair 1 (cPair A B))))
(cPair 1 (cPair (cPair 3 (cPair v A)) (cPair 3 (cPair v B))))))
(cPairPi1 p).
Lemma checkPrfFA3IsPR : isPR 2 checkPrfFA3.
Definition checkPrfEQ1 (p recs : nat) :=
charFunction 2 beq_nat (cPairPi2 (cPairPi2 p)) 0 *
charFunction 2 beq_nat
(codeFormula L codeF codeR (fol.equal L (fol.var L 0) (fol.var L 0)))
(cPairPi1 p).
Lemma checkPrfEQnIsPR :
forall n : nat,
isPR 2
(fun p recs : nat =>
charFunction 2 beq_nat (cPairPi2 (cPairPi2 p)) 0 *
charFunction 2 beq_nat n (cPairPi1 p)).
Lemma checkPrfEQ1IsPR : isPR 2 checkPrfEQ1.
Definition checkPrfEQ2 (p recs : nat) :=
charFunction 2 beq_nat (cPairPi2 (cPairPi2 p)) 0 *
charFunction 2 beq_nat
(codeFormula L codeF codeR
(fol.impH L (fol.equal L (fol.var L 0) (fol.var L 1))
(fol.equal L (fol.var L 1) (fol.var L 0))))
(cPairPi1 p).
Lemma checkPrfEQ2IsPR : isPR 2 checkPrfEQ2.
Definition checkPrfEQ3 (p recs : nat) :=
charFunction 2 beq_nat (cPairPi2 (cPairPi2 p)) 0 *
charFunction 2 beq_nat
(codeFormula L codeF codeR
(fol.impH L (fol.equal L (fol.var L 0) (fol.var L 1))
(fol.impH L (fol.equal L (fol.var L 1) (fol.var L 2))
(fol.equal L (fol.var L 0) (fol.var L 2)))))
(cPairPi1 p).
Lemma checkPrfEQ3IsPR : isPR 2 checkPrfEQ3.
Definition codeAxmEqHelp (n f : nat) : nat :=
nat_rec (fun _ => nat) f
(fun m rec : nat =>
cPair 1
(cPair (cPair 0 (cPair (cPair 0 (m + m)) (cPair 0 (S (m + m))))) rec))
n.
Lemma codeAxmEqHelpIsPR : isPR 2 codeAxmEqHelp.
Definition codeNVars1 (n : nat) : nat :=
nat_rec (fun _ => nat) 0
(fun m rec : nat => S (cPair (cPair 0 (m + m)) rec)) n.
Lemma codeNVars1IsPR : isPR 1 codeNVars1.
Definition codeNVars2 (n : nat) : nat :=
nat_rec (fun _ => nat) 0
(fun m rec : nat => S (cPair (cPair 0 (S (m + m))) rec)) n.
Lemma codeNVars2IsPR : isPR 1 codeNVars2.
Lemma codeNVarsCorrect :
forall n : nat,
codeNVars1 n = codeTerms L codeF n (fst (nVars L n)) /\
codeNVars2 n = codeTerms L codeF n (snd (nVars L n)).