(*  Title:      Pure/Proof/proof_syntax.ML

     Author:     Stefan Berghofer, TU Muenchen

 Function for parsing and printing proof terms.

 *)

 signature PROOF_SYNTAX =

 sig

   val proofT: typ

   val add_proof_syntax: theory -> theory

   val proof_of_term: theory -> bool -> term -> Proofterm.proof

   val term_of_proof: Proofterm.proof -> term

   val cterm_of_proof: theory -> Proofterm.proof -> cterm * (cterm -> Proofterm.proof)

   val strip_sorts_consttypes: Proof.context -> Proof.context

   val read_term: theory -> bool -> typ -> string -> term

   val read_proof: theory -> bool -> bool -> string -> Proofterm.proof

   val proof_syntax: Proofterm.proof -> theory -> theory

   val proof_of: bool -> thm -> Proofterm.proof

   val pretty_proof: Proof.context -> Proofterm.proof -> Pretty.T

   val pretty_proof_of: Proof.context -> bool -> thm -> Pretty.T

 end;

 structure Proof_Syntax : PROOF_SYNTAX =

 struct

 open Proofterm;

 (**** add special syntax for embedding proof terms ****)

 val proofT = Type ("proof", []);

 val paramT = Type ("param", []);

 val paramsT = Type ("params", []);

 val idtT = Type ("idt", []);

 val aT = TFree (Name.aT, []);

 (** constants for theorems and axioms **)

 fun add_proof_atom_consts names thy =

   thy

   |> Sign.root_path

   |> Sign.add_consts_i (map (fn name => (Binding.qualified_name name, proofT, NoSyn)) names);

 (** constants for application and abstraction **)

 fun add_proof_syntax thy =

   thy

   |> Theory.copy

   |> Sign.root_path

   |> Sign.set_defsort []

   |> Sign.add_types [(Binding.name "proof", 0, NoSyn)]

   |> fold (snd oo Sign.declare_const)

       [((Binding.name "Appt", [proofT, aT] ---> proofT), Mixfix ("(1_ %/ _)", [4, 5], 4)),

        ((Binding.name "AppP", [proofT, proofT] ---> proofT), Mixfix ("(1_ %%/ _)", [4, 5], 4)),

        ((Binding.name "Abst", (aT --> proofT) --> proofT), NoSyn),

        ((Binding.name "AbsP", [propT, proofT --> proofT] ---> proofT), NoSyn),

        ((Binding.name "Hyp", propT --> proofT), NoSyn),

        ((Binding.name "Oracle", propT --> proofT), NoSyn),

        ((Binding.name "OfClass", (Term.a_itselfT --> propT) --> proofT), NoSyn),

        ((Binding.name "MinProof", proofT), Delimfix "?")]

   |> Sign.add_nonterminals [Binding.name "param", Binding.name "params"]

   |> Sign.add_syntax_i

       [("_Lam", [paramsT, proofT] ---> proofT, Mixfix ("(1Lam _./ _)", [0, 3], 3)),

        ("_Lam0", [paramT, paramsT] ---> paramsT, Mixfix ("_/ _", [1, 0], 0)),

        ("_Lam0", [idtT, paramsT] ---> paramsT, Mixfix ("_/ _", [1, 0], 0)),

        ("_Lam1", [idtT, propT] ---> paramT, Mixfix ("_: _", [0, 0], 0)),

        ("", paramT --> paramT, Delimfix "'(_')"),

        ("", idtT --> paramsT, Delimfix "_"),

        ("", paramT --> paramsT, Delimfix "_")]

   |> Sign.add_modesyntax_i (Symbol.xsymbolsN, true)

       [("_Lam", [paramsT, proofT] ---> proofT, Mixfix ("(1\\<Lambda>_./ _)", [0, 3], 3)),

        (Syntax.mark_const "Appt", [proofT, aT] ---> proofT, Mixfix ("(1_ \\<cdot>/ _)", [4, 5], 4)),

        (Syntax.mark_const "AppP", [proofT, proofT] ---> proofT, Mixfix ("(1_ \\<bullet>/ _)", [4, 5], 4))]

   |> Sign.add_modesyntax_i ("latex", false)

       [("_Lam", [paramsT, proofT] ---> proofT, Mixfix ("(1\\<^bold>\\<lambda>_./ _)", [0, 3], 3))]

   |> Sign.add_trrules_i (map Syntax.ParsePrintRule

       [(Syntax.mk_appl (Constant "_Lam")

           [Syntax.mk_appl (Constant "_Lam0") [Variable "l", Variable "m"], Variable "A"],

         Syntax.mk_appl (Constant "_Lam")

           [Variable "l", Syntax.mk_appl (Constant "_Lam") [Variable "m", Variable "A"]]),

        (Syntax.mk_appl (Constant "_Lam")

           [Syntax.mk_appl (Constant "_Lam1") [Variable "x", Variable "A"], Variable "B"],

         Syntax.mk_appl (Constant (Syntax.mark_const "AbsP")) [Variable "A",

           (Syntax.mk_appl (Constant "_abs") [Variable "x", Variable "B"])]),

        (Syntax.mk_appl (Constant "_Lam") [Variable "x", Variable "A"],

         Syntax.mk_appl (Constant (Syntax.mark_const "Abst"))

           [(Syntax.mk_appl (Constant "_abs") [Variable "x", Variable "A"])])]);

 (**** translation between proof terms and pure terms ****)

 fun proof_of_term thy ty =

   let

     val thms = PureThy.all_thms_of thy;

     val axms = Theory.all_axioms_of thy;

     fun mk_term t = (if ty then I else map_types (K dummyT))

       (Term.no_dummy_patterns t);

     fun prf_of [] (Bound i) = PBound i

       | prf_of Ts (Const (s, Type ("proof", _))) =

           change_type (if ty then SOME Ts else NONE)

             (case Long_Name.explode s of

                "axm" :: xs =>

                  let

                    val name = Long_Name.implode xs;

                    val prop = (case AList.lookup (op =) axms name of

                        SOME prop => prop

                      | NONE => error ("Unknown axiom " ^ quote name))

                  in PAxm (name, prop, NONE) end

              | "thm" :: xs =>

                  let val name = Long_Name.implode xs;

                  in (case AList.lookup (op =) thms name of

                      SOME thm => fst (strip_combt (fst (strip_combP (Thm.proof_of thm))))

                    | NONE => error ("Unknown theorem " ^ quote name))

                  end

              | _ => error ("Illegal proof constant name: " ^ quote s))

       | prf_of Ts (Const ("OfClass", _) $ Const (c_class, _)) =

           (case try Logic.class_of_const c_class of

             SOME c =>

               change_type (if ty then SOME Ts else NONE)

                 (OfClass (TVar ((Name.aT, 0), []), c))

           | NONE => error ("Bad class constant: " ^ quote c_class))

       | prf_of Ts (Const ("Hyp", _) $ prop) = Hyp prop

       | prf_of Ts (v as Var ((_, Type ("proof", _)))) = Hyp v

       | prf_of [] (Const ("Abst", _) $ Abs (s, T, prf)) =

           if T = proofT then

             error ("Term variable abstraction may not bind proof variable " ^ quote s)

           else Abst (s, if ty then SOME T else NONE,

             incr_pboundvars (~1) 0 (prf_of [] prf))

       | prf_of [] (Const ("AbsP", _) $ t $ Abs (s, _, prf)) =

           AbsP (s, case t of

                 Const ("dummy_pattern", _) => NONE

               | _ $ Const ("dummy_pattern", _) => NONE

               | _ => SOME (mk_term t),

             incr_pboundvars 0 (~1) (prf_of [] prf))

       | prf_of [] (Const ("AppP", _) $ prf1 $ prf2) =

           prf_of [] prf1 %% prf_of [] prf2

       | prf_of Ts (Const ("Appt", _) $ prf $ Const ("TYPE", Type (_, [T]))) =

           prf_of (T::Ts) prf

       | prf_of [] (Const ("Appt", _) $ prf $ t) = prf_of [] prf %

           (case t of Const ("dummy_pattern", _) => NONE | _ => SOME (mk_term t))

       | prf_of _ t = error ("Not a proof term:\n" ^

           Syntax.string_of_term_global thy t)

   in prf_of [] end;

 val AbsPt = Const ("AbsP", [propT, proofT --> proofT] ---> proofT);

 val AppPt = Const ("AppP", [proofT, proofT] ---> proofT);

 val Hypt = Const ("Hyp", propT --> proofT);

 val Oraclet = Const ("Oracle", propT --> proofT);

 val OfClasst = Const ("OfClass", (Term.itselfT dummyT --> propT) --> proofT);

 val MinProoft = Const ("MinProof", proofT);

 val mk_tyapp = fold (fn T => fn prf => Const ("Appt",

   [proofT, Term.itselfT T] ---> proofT) $ prf $ Logic.mk_type T);

 fun term_of _ (PThm (_, ((name, _, NONE), _))) =

       Const (Long_Name.append "thm" name, proofT)

   | term_of _ (PThm (_, ((name, _, SOME Ts), _))) =

       mk_tyapp Ts (Const (Long_Name.append "thm" name, proofT))

   | term_of _ (PAxm (name, _, NONE)) = Const (Long_Name.append "axm" name, proofT)

   | term_of _ (PAxm (name, _, SOME Ts)) =

       mk_tyapp Ts (Const (Long_Name.append "axm" name, proofT))

   | term_of _ (OfClass (T, c)) =

       mk_tyapp [T] (OfClasst $ Const (Logic.const_of_class c, Term.itselfT dummyT --> propT))

   | term_of _ (PBound i) = Bound i

   | term_of Ts (Abst (s, opT, prf)) =

       let val T = the_default dummyT opT

       in Const ("Abst", (T --> proofT) --> proofT) $

         Abs (s, T, term_of (T::Ts) (incr_pboundvars 1 0 prf))

       end

   | term_of Ts (AbsP (s, t, prf)) =

       AbsPt $ the_default (Term.dummy_pattern propT) t $

         Abs (s, proofT, term_of (proofT::Ts) (incr_pboundvars 0 1 prf))

   | term_of Ts (prf1 %% prf2) =

       AppPt $ term_of Ts prf1 $ term_of Ts prf2

   | term_of Ts (prf % opt) =

       let val t = the_default (Term.dummy_pattern dummyT) opt

       in Const ("Appt",

         [proofT, fastype_of1 (Ts, t) handle TERM _ => dummyT] ---> proofT) $

           term_of Ts prf $ t

       end

   | term_of Ts (Hyp t) = Hypt $ t

   | term_of Ts (Oracle (_, t, _)) = Oraclet $ t

   | term_of Ts MinProof = MinProoft;

 val term_of_proof = term_of [];

 fun cterm_of_proof thy prf =

   let

     val thm_names = map fst (PureThy.all_thms_of thy);

     val axm_names = map fst (Theory.all_axioms_of thy);

     val thy' = thy

       |> add_proof_syntax

       |> add_proof_atom_consts

         (map (Long_Name.append "axm") axm_names @ map (Long_Name.append "thm") thm_names);

   in

     (cterm_of thy' (term_of_proof prf), proof_of_term thy true o Thm.term_of)

   end;

 fun strip_sorts_consttypes ctxt =

   let val {constants = (_, tab), ...} = Consts.dest (ProofContext.consts_of ctxt)

   in Symtab.fold (fn (s, (T, _)) =>

       ProofContext.add_const_constraint (s, SOME (Type.strip_sorts T)))

     tab ctxt

   end;

 fun read_term thy topsort =

   let

     val thm_names = filter_out (fn s => s = "") (map fst (PureThy.all_thms_of thy));

     val axm_names = map fst (Theory.all_axioms_of thy);

     val ctxt = thy

       |> add_proof_syntax

       |> add_proof_atom_consts

         (map (Long_Name.append "axm") axm_names @ map (Long_Name.append "thm") thm_names)

       |> ProofContext.init_global

       |> ProofContext.allow_dummies

       |> ProofContext.set_mode ProofContext.mode_schematic

       |> (if topsort then

             strip_sorts_consttypes #>

             ProofContext.set_defsort []

           else I);

   in

     fn ty => fn s =>

       (if ty = propT then Syntax.parse_prop else Syntax.parse_term) ctxt s

       |> Type_Infer.constrain ty |> Syntax.check_term ctxt

   end;

 fun read_proof thy topsort =

   let val rd = read_term thy topsort proofT

   in fn ty => fn s => proof_of_term thy ty (Logic.varify_global (rd s)) end;

 fun proof_syntax prf =

   let

     val thm_names = Symtab.keys (fold_proof_atoms true

       (fn PThm (_, ((name, _, _), _)) => if name <> "" then Symtab.update (name, ()) else I

         | _ => I) [prf] Symtab.empty);

     val axm_names = Symtab.keys (fold_proof_atoms true

       (fn PAxm (name, _, _) => Symtab.update (name, ()) | _ => I) [prf] Symtab.empty);

   in

     add_proof_syntax #>

     add_proof_atom_consts

       (map (Long_Name.append "thm") thm_names @ map (Long_Name.append "axm") axm_names)

   end;

 fun proof_of full thm =

   let

     val thy = Thm.theory_of_thm thm;

     val prop = Thm.full_prop_of thm;

     val prf = Thm.proof_of thm;

     val prf' = (case strip_combt (fst (strip_combP prf)) of

         (PThm (_, ((_, prop', _), body)), _) => if prop = prop' then join_proof body else prf

       | _ => prf)

   in if full then Reconstruct.reconstruct_proof thy prop prf' else prf' end;

 fun pretty_proof ctxt prf =

   ProofContext.pretty_term_abbrev

     (ProofContext.transfer_syntax (proof_syntax prf (ProofContext.theory_of ctxt)) ctxt)

     (term_of_proof prf);

 fun pretty_proof_of ctxt full th =

   pretty_proof ctxt (proof_of full th);

 end;