;; 2014-04-28.  realeqbound.scm

(load "~/git/minlog/init.scm")

(set! COMMENT-FLAG #f)
(libload "nat.scm")
(libload "numbers.scm")
(libload "simpreal.scm")
(libload "real.scm")
(set! COMMENT-FLAG #t)

(display-alg "nat" "pos" "int" "rat" "rea")

(display-idpc "Cauchy")
(pp "CauchyElim")

(display-idpc "RealEq")
(pp "RealEqElim")
(pp "RealEqElimVariant")

;; RealEqChar1
(set-goal "allnc as all M allnc bs all N(Cauchy as M -> Cauchy bs N ->
      RealConstr as M===RealConstr bs N -> 
      all k ex n1 all n(n1<=n -> abs(as n-bs n)<=1/2**k))")
(assume "as" "M" "bs" "N" "CasM" "CbsN" "EqHyp" "k")
(ex-intro (pt "M(IntS(IntS k))max N(IntS(IntS k))"))
(assume "n" "Max<=n")
(use "RatLeTrans" (pt "1/2**(IntS(IntS k))+1/2**(IntS k)+1/2**(IntS(IntS k))"))
(use "RatLeTrans" (pt "abs(as n-as(M(IntS(IntS k))))+
                       abs(as(M(IntS(IntS k)))-bs(N(IntS(IntS k))))+
                       abs(bs(N(IntS(IntS k)))-bs n)"))
(use "RatAbsLe3")
(use "RatPlusLe3")
(use "CauchyElim" (pt "M"))
(use "CasM")
(use "NatLeTrans" (pt "(M(IntS(IntS k)))max(N(IntS(IntS k)))"))
(use "NatMaxUB1")
(use "Max<=n")
(use "Truth")

(use "RealEqElimVariant")
(use "EqHyp")
(use "CauchyElim" (pt "N"))
(use "CbsN")
(use "Truth")
(use "NatLeTrans" (pt "(M(IntS(IntS k)))max(N(IntS(IntS k)))"))
(use "NatMaxUB2")
(use "Max<=n")

(ord-field-simp-bwd)
;; Proof finished.

(define eterm (proof-to-extracted-term))
(define neterm (rename-variables (nt eterm)))
(pp neterm)

;; RealEqChar2
(set-goal "all as,M,bs,N(Cauchy as M -> Cauchy bs N ->
           all k ex n0 all n(n0<=n -> abs(as n-bs n)<=1/2**k) ->
           RealConstr as M===RealConstr bs N)")
(assume "as" "M" "bs" "N" "CasM" "CbsN" "AllExHyp")
(use "RealEqIntro")
(assume "k")
(use "RatLeCritGen")
(assume "l")
(ng #t)
(inst-with-to "AllExHyp" (pt "l") "InstAllExHyp")
(drop "AllExHyp")
(by-assume "InstAllExHyp" "n0" "InstAllExHypKernel")
;; We now want to use n as an abbreviation for the complex term
;; ((M(k+1))max(N(k+1)))max n0.  Hence we introduce via cut the formula
;; all n(n=term -> goal)
(cut "all n(n=((M(IntS k))max(N(IntS k)))max n0 ->
      abs(as(M(IntS k))-bs(N(IntS k)))<=
      1/2**k+(1/2**l))")
(assume "AllHyp")
(use "AllHyp" (pt "((M(IntS k))max(N(IntS k)))max n0"))
(use "Truth")
(assume "n" "nDef")
(inst-with-to "InstAllExHypKernel" (pt "n") "Mid")
(drop  "InstAllExHypKernel")
(use "RatLeTrans" (pt "1/2**(IntS k)+(1/2**l)+1/2**(IntS k)"))
(use "RatLeTrans" (pt "abs(as(M(IntS k))-as n)+abs(as n-bs n)+
                       abs(bs n-bs(N(IntS k)))"))
(use "RatAbsLe3")
(use "RatPlusLe3")
(use "CauchyElim" (pt "M"))
(use "CasM")
(use "Truth")
(simp "nDef")
(use "NatLeTrans" (pt "NatMax(M(IntS k))(N(IntS k))"))
(use "NatMaxUB1")
(use "NatMaxUB1")
(use "Mid")
(simp "nDef")
(use "NatMaxUB2")

(use "CauchyElim" (pt "N"))
(use "CbsN")
(use "NatLeTrans" (pt "NatMax(M(IntS k))(N(IntS k))"))
(use "NatMaxUB2")
(simp "nDef")
(use "NatMaxUB1")
(use "Truth")

(ord-field-simp-bwd)
;; Proof finished.

;; RatSeqFinBound
(set-goal "all as,n ex a all m(m<n -> as m<=a)")
(assume "as")
(ind)
  (ex-intro (pt "IntP One#One"))
  (assume "m" "Absurd")
  (use "Efq")
  (use "Absurd")
(assume "n" "IH")
(by-assume "IH" "a" "H")
(ex-intro (pt "a max as n"))
(assume "m" "m<Succ n")
(use "NatLtSuccCases" (pt "n") (pt "m"))
(use "m<Succ n")
(assume "m<n")
(use "RatLeTrans" (pt "a"))
(use-with "H" (pt "m") "m<n")
(use "RatMaxUB1")
(assume "m=n")
(simp "m=n")
(use "RatMaxUB2")
;; Proof finished.
;; (save "RatSeqFinBound")

(define eterm (proof-to-extracted-term))
(define neterm (rename-variables (nt eterm)))
(pp neterm)
;; [as,n](Rec nat=>rat)n 1([n0,a]a max as n0)

;; RealBound
(set-goal "all as,M(Cauchy as M -> ex a all n as n<=a)")
(assume "as" "M" "CasM")
(cut "ex a all m(m<M Zero -> as m<=a)")
(assume "ExHyp")
(by-assume "ExHyp" "a" "FinBound")
(ex-intro (pt "a max(as(M Zero))+1"))
(assume "n")
(cases (pt "n<M Zero"))
(assume "n<M Zero")
(use "RatLeTrans" (pt "a"))
(use "FinBound")
(use "n<M Zero")
(use "RatLeTrans" (pt "a max(as(M Zero))"))
(use "RatMaxUB1")
(use "Truth")
(assume "n<M Zero -> F")
(use "RatLeTrans" (pt "as(M Zero)+(as n-as(M Zero))"))
(ord-field-simp-bwd)
(use "RatLeMonPlus")
(use "RatMaxUB2")
(use "RatLeTrans" (pt "abs(as n-as(M Zero))"))
(use "RatAbsUB1")
(use "RatLeTrans" (pt "IntP One/2**IntZero"))
(use "CauchyElim" (pt "M"))
(use "CasM")
(use "NatNotLtToLe")
(use "n<M Zero -> F")
(use "Truth")
(use "Truth")
(use "RatSeqFinBound")
;; Proof finished.

(define eterm (proof-to-extracted-term))
(define neterm (rename-variables (nt eterm)))
(pp neterm)

(animate "RatSeqFinBound")
(define neterm (rename-variables (nt eterm)))
(pp neterm)
