From ff5454812f9e2720bd90c3a5437505644f63b487 Mon Sep 17 00:00:00 2001 From: Josh Chen Date: Fri, 31 Jul 2020 14:56:24 +0200 Subject: (FEAT) Term elaboration of assumption and goal statements. . spartan/core/goals.ML . spartan/core/elaboration.ML . spartan/core/elaborated_statement.ML (FEAT) More context tacticals and search tacticals. . spartan/core/context_tactical.ML (FEAT) Improved subgoal focus. Moves fully elaborated assumptions into the context (MINOR INCOMPATIBILITY). . spartan/core/focus.ML (FIX) Normalize facts in order to be able to resolve properly. . spartan/core/typechecking.ML (MAIN) New definitions. (MAIN) Renamed theories and theorems. (MAIN) Refactor theories to fit new features. --- spartan/core/Spartan.thy | 70 +++--- spartan/core/context_tactical.ML | 100 ++++++++ spartan/core/elaborated_assumption.ML | 446 ---------------------------------- spartan/core/elaborated_statement.ML | 441 +++++++++++++++++++++++++++++++++ spartan/core/elaboration.ML | 17 +- spartan/core/focus.ML | 96 +++++--- spartan/core/goals.ML | 10 +- spartan/core/tactics.ML | 3 +- spartan/core/typechecking.ML | 8 +- 9 files changed, 668 insertions(+), 523 deletions(-) delete mode 100644 spartan/core/elaborated_assumption.ML create mode 100644 spartan/core/elaborated_statement.ML (limited to 'spartan/core') diff --git a/spartan/core/Spartan.thy b/spartan/core/Spartan.thy index faa692d..27edd51 100644 --- a/spartan/core/Spartan.thy +++ b/spartan/core/Spartan.thy @@ -8,9 +8,9 @@ imports keywords "Theorem" "Lemma" "Corollary" "Proposition" "Definition" :: thy_goal_stmt and "assuming" :: prf_asm % "proof" and - "focus" "\" "\<^item>" "\<^enum>" "~" :: prf_script_goal % "proof" and + "focus" "\<^item>" "\<^enum>" "\" "\" "~" :: prf_script_goal % "proof" and "congruence" "print_coercions" :: thy_decl and - "rhs" "derive" "prems" "vars" :: quasi_command + "rhs" "def" "vars" :: quasi_command begin @@ -198,8 +198,8 @@ lemmas [form] = PiF SigF and [intro] = PiI SigI and [intros] = PiI[rotated] SigI and - [elim "?f"] = PiE and - [elim "?p"] = SigE and + [elim ?f] = PiE and + [elim ?p] = SigE and [comp] = beta Sig_comp and [cong] = Pi_cong lam_cong Sig_cong @@ -217,7 +217,7 @@ subsection \Statement commands\ ML_file \focus.ML\ ML_file \elaboration.ML\ -ML_file \elaborated_assumption.ML\ +ML_file \elaborated_statement.ML\ ML_file \goals.ML\ subsection \Proof methods\ @@ -229,10 +229,6 @@ method_setup rule = \Attrib.thms >> (fn ths => K (CONTEXT_METHOD ( CHEADGOAL o SIDE_CONDS (rule_ctac ths))))\ -method_setup rules = - \Attrib.thms >> (fn ths => K (CONTEXT_METHOD ( - CREPEAT o CHEADGOAL o SIDE_CONDS (rule_ctac ths))))\ - method_setup dest = \Scan.lift (Scan.option (Args.parens Parse.int)) -- Attrib.thms >> (fn (n_opt, ths) => K (CONTEXT_METHOD ( @@ -411,10 +407,10 @@ lemma funcompI [typechk]: lemma funcomp_assoc [comp]: assumes + "A: U i" "f: A \ B" "g: B \ C" "h: \x: C. D x" - "A: U i" shows "(h \\<^bsub>B\<^esub> g) \\<^bsub>A\<^esub> f \ h \\<^bsub>A\<^esub> g \\<^bsub>A\<^esub> f" unfolding funcomp_def by reduce @@ -430,10 +426,9 @@ lemma funcomp_lambda_comp [comp]: lemma funcomp_apply_comp [comp]: assumes + "A: U i" "B: U i" "\x y. x: B \ C x: U i" "f: A \ B" "g: \x: B. C x" "x: A" - "A: U i" "B: U i" - "\x y. x: B \ C x: U i" shows "(g \\<^bsub>A\<^esub> f) x \ g (f x)" unfolding funcomp_def by reduce @@ -449,17 +444,17 @@ subsection \Identity function\ abbreviation id where "id A \ \x: A. x" lemma - id_type[typechk]: "A: U i \ id A: A \ A" and + id_type [typechk]: "A: U i \ id A: A \ A" and id_comp [comp]: "x: A \ (id A) x \ x" \ \for the occasional manual rewrite\ by reduce+ lemma id_left [comp]: - assumes "f: A \ B" "A: U i" "B: U i" + assumes "A: U i" "B: U i" "f: A \ B" shows "(id B) \\<^bsub>A\<^esub> f \ f" by (subst eta_exp[of f]) (reduce, rule eta) lemma id_right [comp]: - assumes "f: A \ B" "A: U i" "B: U i" + assumes "A: U i" "B: U i" "f: A \ B" shows "f \\<^bsub>A\<^esub> (id A) \ f" by (subst eta_exp[of f]) (reduce, rule eta) @@ -480,10 +475,7 @@ lemma fst_type [typechk]: lemma fst_comp [comp]: assumes - "a: A" - "b: B a" - "A: U i" - "\x. x: A \ B x: U i" + "A: U i" "\x. x: A \ B x: U i" "a: A" "b: B a" shows "fst A B \ a" unfolding fst_def by reduce @@ -493,7 +485,7 @@ lemma snd_type [typechk]: unfolding snd_def by typechk reduce lemma snd_comp [comp]: - assumes "a: A" "b: B a" "A: U i" "\x. x: A \ B x: U i" + assumes "A: U i" "\x. x: A \ B x: U i" "a: A" "b: B a" shows "snd A B \ b" unfolding snd_def by reduce @@ -513,36 +505,48 @@ subsection \Projections\ Lemma fst [typechk]: assumes - "p: \x: A. B x" "A: U i" "\x. x: A \ B x: U i" + "p: \x: A. B x" shows "fst p: A" by typechk Lemma snd [typechk]: assumes - "p: \x: A. B x" "A: U i" "\x. x: A \ B x: U i" + "p: \x: A. B x" shows "snd p: B (fst p)" by typechk -method fst for p::o = rule fst[of p] -method snd for p::o = rule snd[of p] +method fst for p::o = rule fst[where ?p=p] +method snd for p::o = rule snd[where ?p=p] -subsection \Properties of \\ +text \Double projections:\ -Lemma (derive) Sig_dist_exp: +definition [implicit]: "p\<^sub>1\<^sub>1 p \ Spartan.fst ? ? (Spartan.fst ? ? p)" +definition [implicit]: "p\<^sub>1\<^sub>2 p \ Spartan.snd ? ? (Spartan.fst ? ? p)" +definition [implicit]: "p\<^sub>2\<^sub>1 p \ Spartan.fst ? ? (Spartan.snd ? ? p)" +definition [implicit]: "p\<^sub>2\<^sub>2 p \ Spartan.snd ? ? (Spartan.snd ? ? p)" + +translations + "CONST p\<^sub>1\<^sub>1 p" \ "fst (fst p)" + "CONST p\<^sub>1\<^sub>2 p" \ "snd (fst p)" + "CONST p\<^sub>2\<^sub>1 p" \ "fst (snd p)" + "CONST p\<^sub>2\<^sub>2 p" \ "snd (snd p)" + +Lemma (def) distribute_Sig: assumes - "p: \x: A. B x \ C x" "A: U i" "\x. x: A \ B x: U i" "\x. x: A \ C x: U i" + "p: \x: A. B x \ C x" shows "(\x: A. B x) \ (\x: A. C x)" -proof intro - have "fst p: A" and "snd p: B (fst p) \ C (fst p)" by typechk+ - thus ": \x: A. B x" - and ": \x: A. C x" - by typechk+ -qed + proof intro + have "fst p: A" and "snd p: B (fst p) \ C (fst p)" + by typechk+ + thus ": \x: A. B x" + and ": \x: A. C x" + by typechk+ + qed end diff --git a/spartan/core/context_tactical.ML b/spartan/core/context_tactical.ML index a5159f6..b5a6c00 100644 --- a/spartan/core/context_tactical.ML +++ b/spartan/core/context_tactical.ML @@ -2,6 +2,10 @@ Author: Joshua Chen More context tactics, and context tactic combinators. + +Contains code modified from + ~~/Pure/search.ML + ~~/Pure/tactical.ML *) infix 1 CTHEN CTHEN' CTHEN_ALL_NEW CTHEN_ALL_NEW_FWD @@ -23,6 +27,7 @@ val CORELSE': context_tactic' * context_tactic' -> context_tactic' val CAPPEND': context_tactic' * context_tactic' -> context_tactic' val CTRY: context_tactic -> context_tactic val CREPEAT: context_tactic -> context_tactic +val CREPEAT1: context_tactic -> context_tactic val CFILTER: (context_state -> bool) -> context_tactic -> context_tactic val CCHANGED: context_tactic -> context_tactic val CTHEN_ALL_NEW: context_tactic' * context_tactic' -> context_tactic' @@ -34,6 +39,16 @@ val CHEADGOAL: context_tactic' -> context_tactic val CALLGOALS: context_tactic' -> context_tactic val CSOMEGOAL: context_tactic' -> context_tactic val CRANGE: context_tactic' list -> context_tactic' +val CFIRST: context_tactic list -> context_tactic +val CFIRST': context_tactic' list -> context_tactic' +val CTHEN_BEST_FIRST: context_tactic -> (context_state -> bool) -> + (context_state -> int) -> context_tactic -> context_tactic +val CBEST_FIRST: (context_state -> bool) -> (context_state -> int) -> + context_tactic -> context_tactic +val CTHEN_ASTAR: context_tactic -> (context_state -> bool) -> + (int -> context_state -> int) -> context_tactic -> context_tactic +val CASTAR: (context_state -> bool) -> (int -> context_state -> int) -> + context_tactic -> context_tactic end = struct @@ -74,6 +89,8 @@ fun CREPEAT ctac = | SOME (cst, q) => rep (q :: qs) cst); in fn cst => Seq.make_results (Seq.make (fn () => rep [] cst)) end +fun CREPEAT1 ctac = ctac CTHEN CREPEAT ctac + fun CFILTER pred ctac cst = ctac cst |> Seq.filter_results @@ -147,6 +164,89 @@ fun CSOMEGOAL ctac (cst as (_, st)) = fun CRANGE [] _ = all_ctac | CRANGE (ctac :: ctacs) i = CRANGE ctacs (i + 1) CTHEN ctac i +fun CFIRST ctacs = fold_rev (curry op CORELSE) ctacs no_ctac + +(*FIRST' [tac1,...,tacn] i equals tac1 i ORELSE ... ORELSE tacn i*) +fun CFIRST' ctacs = fold_rev (curry op CORELSE') ctacs (K no_ctac) + + +(** Search tacticals **) + +(* Best-first search *) + +structure Thm_Heap = Heap ( + type elem = int * thm; + val ord = prod_ord int_ord (Term_Ord.term_ord o apply2 Thm.prop_of) +) + +structure Context_State_Heap = Heap ( + type elem = int * context_state; + val ord = prod_ord int_ord (Term_Ord.term_ord o apply2 (Thm.prop_of o #2)) +) + +fun some_of_list [] = NONE + | some_of_list (x :: l) = SOME (x, Seq.make (fn () => some_of_list l)) + +(*Check for and delete duplicate proof states*) +fun delete_all_min (cst as (_, st)) heap = + if Context_State_Heap.is_empty heap then heap + else if Thm.eq_thm (st, #2 (#2 (Context_State_Heap.min heap))) + then delete_all_min cst (Context_State_Heap.delete_min heap) + else heap + +(*Best-first search for a state that satisfies satp (incl initial state) + Function sizef estimates size of problem remaining (smaller means better). + tactic tac0 sets up the initial priority queue, while tac1 searches it. *) +fun CTHEN_BEST_FIRST ctac0 satp sizef ctac = + let + fun pairsize cst = (sizef cst, cst); + fun bfs (news, nst_heap) = + (case List.partition satp news of + ([], nonsats) => next (fold_rev Context_State_Heap.insert (map pairsize nonsats) nst_heap) + | (sats, _) => some_of_list sats) + and next nst_heap = + if Context_State_Heap.is_empty nst_heap then NONE + else + let + val (n, cst) = Context_State_Heap.min nst_heap; + in + bfs (Seq.list_of (Seq.filter_results (ctac cst)), delete_all_min cst (Context_State_Heap.delete_min nst_heap)) + end; + fun btac cst = bfs (Seq.list_of (Seq.filter_results (ctac0 cst)), Context_State_Heap.empty) + in fn cst => Seq.make_results (Seq.make (fn () => btac cst)) end + +(*Ordinary best-first search, with no initial tactic*) +val CBEST_FIRST = CTHEN_BEST_FIRST all_ctac + + +(* A*-like search *) + +(*Insertion into priority queue of states, marked with level*) +fun insert_with_level (lnth: int * int * context_state) [] = [lnth] + | insert_with_level (l, m, cst) ((l', n, cst') :: csts) = + if n < m then (l', n, cst') :: insert_with_level (l, m, cst) csts + else if n = m andalso Thm.eq_thm (#2 cst, #2 cst') then (l', n, cst') :: csts + else (l, m, cst) :: (l', n, cst') :: csts; + +fun CTHEN_ASTAR ctac0 satp costf ctac = + let + fun bfs (news, nst, level) = + let fun cost cst = (level, costf level cst, cst) in + (case List.partition satp news of + ([], nonsats) => next (fold_rev (insert_with_level o cost) nonsats nst) + | (sats, _) => some_of_list sats) + end + and next [] = NONE + | next ((level, n, cst) :: nst) = + bfs (Seq.list_of (Seq.filter_results (ctac cst)), nst, level + 1) + in fn cst => Seq.make_results + (Seq.make (fn () => bfs (Seq.list_of (Seq.filter_results (ctac0 cst)), [], 0))) + end + +(*Ordinary ASTAR, with no initial tactic*) +val CASTAR = CTHEN_ASTAR all_ctac; + + end open Context_Tactical diff --git a/spartan/core/elaborated_assumption.ML b/spartan/core/elaborated_assumption.ML deleted file mode 100644 index af3a384..0000000 --- a/spartan/core/elaborated_assumption.ML +++ /dev/null @@ -1,446 +0,0 @@ -(* Title: elaborated_assumption.ML - Author: Joshua Chen - -Term elaboration for goal and proof assumptions. - -Contains code from parts of - ~~/Pure/Isar/element.ML and - ~~/Pure/Isar/expression.ML -in both verbatim and modified forms. -*) - -structure Elaborated_Assumption: sig - -val read_goal_statement: - (string, string, Facts.ref) Element.ctxt list -> - (string, string) Element.stmt -> - Proof.context -> - (Attrib.binding * (term * term list) list) list * Proof.context - -end = struct - - -(*Apply elaboration to the list format assumptions are given in*) -fun elaborate ctxt assms = - let - fun subst_term env = Envir.subst_term (Envir.type_env env, Envir.term_env env) - fun elab_fact (fact, xs) assums = - let val (subst, fact') = Elab.elab_stmt ctxt assums fact in - ((fact', map (subst_term subst) xs), Thm.cterm_of ctxt fact' :: assums) - end - fun elab (b, facts) assums = - let val (facts', assums') = fold_map elab_fact facts assums - in ((b, facts'), assums') end - in #1 (fold_map elab assms []) end - - -(* Goal assumptions *) - -(*Most of the code in this section is copied verbatim from the originals; the - only change is a modification to`activate_i` incorporating elaboration.*) - -local - -fun mk_type T = (Logic.mk_type T, []) -fun mk_term t = (t, []) -fun mk_propp (p, pats) = (Type.constraint propT p, pats) - -fun dest_type (T, []) = Logic.dest_type T -fun dest_term (t, []) = t -fun dest_propp (p, pats) = (p, pats) - -fun extract_inst (_, (_, ts)) = map mk_term ts -fun restore_inst ((l, (p, _)), cs) = (l, (p, map dest_term cs)) - -fun extract_eqns es = map (mk_term o snd) es -fun restore_eqns (es, cs) = map2 (fn (b, _) => fn c => (b, dest_term c)) es cs - -fun extract_elem (Element.Fixes fixes) = map (#2 #> the_list #> map mk_type) fixes - | extract_elem (Element.Constrains csts) = map (#2 #> single #> map mk_type) csts - | extract_elem (Element.Assumes asms) = map (#2 #> map mk_propp) asms - | extract_elem (Element.Defines defs) = map (fn (_, (t, ps)) => [mk_propp (t, ps)]) defs - | extract_elem (Element.Notes _) = [] - | extract_elem (Element.Lazy_Notes _) = [] - -fun restore_elem (Element.Fixes fixes, css) = - (fixes ~~ css) |> map (fn ((x, _, mx), cs) => - (x, cs |> map dest_type |> try hd, mx)) |> Element.Fixes - | restore_elem (Element.Constrains csts, css) = - (csts ~~ css) |> map (fn ((x, _), cs) => - (x, cs |> map dest_type |> hd)) |> Element.Constrains - | restore_elem (Element.Assumes asms, css) = - (asms ~~ css) |> map (fn ((b, _), cs) => (b, map dest_propp cs)) |> Element.Assumes - | restore_elem (Element.Defines defs, css) = - (defs ~~ css) |> map (fn ((b, _), [c]) => (b, dest_propp c)) |> Element.Defines - | restore_elem (elem as Element.Notes _, _) = elem - | restore_elem (elem as Element.Lazy_Notes _, _) = elem - -fun prep (_, pats) (ctxt, t :: ts) = - let val ctxt' = Proof_Context.augment t ctxt - in - ((t, Syntax.check_props - (Proof_Context.set_mode Proof_Context.mode_pattern ctxt') pats), - (ctxt', ts)) - end - -fun check cs ctxt = - let - val (cs', (ctxt', _)) = fold_map prep cs - (ctxt, Syntax.check_terms - (Proof_Context.set_mode Proof_Context.mode_schematic ctxt) (map fst cs)) - in (cs', ctxt') end - -fun inst_morphism params ((prfx, mandatory), insts') ctxt = - let - (*parameters*) - val parm_types = map #2 params; - val type_parms = fold Term.add_tfreesT parm_types []; - - (*type inference*) - val parm_types' = map (Type_Infer.paramify_vars o Logic.varifyT_global) parm_types; - val type_parms' = fold Term.add_tvarsT parm_types' []; - val checked = - (map (Logic.mk_type o TVar) type_parms' @ map2 Type.constraint parm_types' insts') - |> Syntax.check_terms (Config.put Type_Infer.object_logic false ctxt) - val (type_parms'', insts'') = chop (length type_parms') checked; - - (*context*) - val ctxt' = fold Proof_Context.augment checked ctxt; - val certT = Thm.trim_context_ctyp o Thm.ctyp_of ctxt'; - val cert = Thm.trim_context_cterm o Thm.cterm_of ctxt'; - - (*instantiation*) - val instT = - (type_parms ~~ map Logic.dest_type type_parms'') - |> map_filter (fn (v, T) => if TFree v = T then NONE else SOME (v, T)); - val cert_inst = - ((map #1 params ~~ map (Term_Subst.instantiateT_frees instT) parm_types) ~~ insts'') - |> map_filter (fn (v, t) => if Free v = t then NONE else SOME (v, cert t)); - in - (Element.instantiate_normalize_morphism (map (apsnd certT) instT, cert_inst) $> - Morphism.binding_morphism "Expression.inst" (Binding.prefix mandatory prfx), ctxt') - end; - -fun abs_def ctxt = - Thm.cterm_of ctxt #> Assumption.assume ctxt #> Local_Defs.abs_def_rule ctxt #> Thm.prop_of; - -fun declare_elem prep_var (Element.Fixes fixes) ctxt = - let val (vars, _) = fold_map prep_var fixes ctxt - in ctxt |> Proof_Context.add_fixes vars |> snd end - | declare_elem prep_var (Element.Constrains csts) ctxt = - ctxt |> fold_map (fn (x, T) => prep_var (Binding.name x, SOME T, NoSyn)) csts |> snd - | declare_elem _ (Element.Assumes _) ctxt = ctxt - | declare_elem _ (Element.Defines _) ctxt = ctxt - | declare_elem _ (Element.Notes _) ctxt = ctxt - | declare_elem _ (Element.Lazy_Notes _) ctxt = ctxt; - -fun parameters_of thy strict (expr, fixed) = - let - val ctxt = Proof_Context.init_global thy; - - fun reject_dups message xs = - (case duplicates (op =) xs of - [] => () - | dups => error (message ^ commas dups)); - - fun parm_eq ((p1, mx1), (p2, mx2)) = - p1 = p2 andalso - (Mixfix.equal (mx1, mx2) orelse - error ("Conflicting syntax for parameter " ^ quote p1 ^ " in expression" ^ - Position.here_list [Mixfix.pos_of mx1, Mixfix.pos_of mx2])); - - fun params_loc loc = Locale.params_of thy loc |> map (apfst #1); - fun params_inst (loc, (prfx, (Expression.Positional insts, eqns))) = - let - val ps = params_loc loc; - val d = length ps - length insts; - val insts' = - if d < 0 then - error ("More arguments than parameters in instantiation of locale " ^ - quote (Locale.markup_name ctxt loc)) - else insts @ replicate d NONE; - val ps' = (ps ~~ insts') |> - map_filter (fn (p, NONE) => SOME p | (_, SOME _) => NONE); - in (ps', (loc, (prfx, (Expression.Positional insts', eqns)))) end - | params_inst (loc, (prfx, (Expression.Named insts, eqns))) = - let - val _ = - reject_dups "Duplicate instantiation of the following parameter(s): " - (map fst insts); - val ps' = (insts, params_loc loc) |-> fold (fn (p, _) => fn ps => - if AList.defined (op =) ps p then AList.delete (op =) p ps - else error (quote p ^ " not a parameter of instantiated expression")); - in (ps', (loc, (prfx, (Expression.Named insts, eqns)))) end; - fun params_expr is = - let - val (is', ps') = fold_map (fn i => fn ps => - let - val (ps', i') = params_inst i; - val ps'' = distinct parm_eq (ps @ ps'); - in (i', ps'') end) is [] - in (ps', is') end; - - val (implicit, expr') = params_expr expr; - - val implicit' = map #1 implicit; - val fixed' = map (Variable.check_name o #1) fixed; - val _ = reject_dups "Duplicate fixed parameter(s): " fixed'; - val implicit'' = - if strict then [] - else - let - val _ = - reject_dups - "Parameter(s) declared simultaneously in expression and for clause: " - (implicit' @ fixed'); - in map (fn (x, mx) => (Binding.name x, NONE, mx)) implicit end; - in (expr', implicit'' @ fixed) end; - -fun parse_elem prep_typ prep_term ctxt = - Element.map_ctxt - {binding = I, - typ = prep_typ ctxt, - term = prep_term (Proof_Context.set_mode Proof_Context.mode_schematic ctxt), - pattern = prep_term (Proof_Context.set_mode Proof_Context.mode_pattern ctxt), - fact = I, - attrib = I}; - -fun prepare_stmt prep_prop prep_obtains ctxt stmt = - (case stmt of - Element.Shows raw_shows => - raw_shows |> (map o apsnd o map) (fn (t, ps) => - (prep_prop (Proof_Context.set_mode Proof_Context.mode_schematic ctxt) t, - map (prep_prop (Proof_Context.set_mode Proof_Context.mode_pattern ctxt)) ps)) - | Element.Obtains raw_obtains => - let - val ((_, thesis), thesis_ctxt) = Obtain.obtain_thesis ctxt; - val obtains = prep_obtains thesis_ctxt thesis raw_obtains; - in map (fn (b, t) => ((b, []), [(t, [])])) obtains end); - -fun finish_fixes (parms: (string * typ) list) = map (fn (binding, _, mx) => - let val x = Binding.name_of binding - in (binding, AList.lookup (op =) parms x, mx) end) - -fun finish_inst ctxt (loc, (prfx, inst)) = - let - val thy = Proof_Context.theory_of ctxt; - val (morph, _) = inst_morphism (map #1 (Locale.params_of thy loc)) (prfx, inst) ctxt; - in (loc, morph) end - -fun closeup _ _ false elem = elem - | closeup (outer_ctxt, ctxt) parms true elem = - let - (*FIXME consider closing in syntactic phase -- before type checking*) - fun close_frees t = - let - val rev_frees = - Term.fold_aterms (fn Free (x, T) => - if Variable.is_fixed outer_ctxt x orelse AList.defined (op =) parms x then I - else insert (op =) (x, T) | _ => I) t []; - in fold (Logic.all o Free) rev_frees t end; - - fun no_binds [] = [] - | no_binds _ = error "Illegal term bindings in context element"; - in - (case elem of - Element.Assumes asms => Element.Assumes (asms |> map (fn (a, propps) => - (a, map (fn (t, ps) => (close_frees t, no_binds ps)) propps))) - | Element.Defines defs => Element.Defines (defs |> map (fn ((name, atts), (t, ps)) => - let val ((c, _), t') = Local_Defs.cert_def ctxt (K []) (close_frees t) - in ((Thm.def_binding_optional (Binding.name c) name, atts), (t', no_binds ps)) end)) - | e => e) - end - -fun finish_elem _ parms _ (Element.Fixes fixes) = Element.Fixes (finish_fixes parms fixes) - | finish_elem _ _ _ (Element.Constrains _) = Element.Constrains [] - | finish_elem ctxts parms do_close (Element.Assumes asms) = closeup ctxts parms do_close (Element.Assumes asms) - | finish_elem ctxts parms do_close (Element.Defines defs) = closeup ctxts parms do_close (Element.Defines defs) - | finish_elem _ _ _ (elem as Element.Notes _) = elem - | finish_elem _ _ _ (elem as Element.Lazy_Notes _) = elem - -fun check_autofix insts eqnss elems concl ctxt = - let - val inst_cs = map extract_inst insts; - val eqns_cs = map extract_eqns eqnss; - val elem_css = map extract_elem elems; - val concl_cs = (map o map) mk_propp (map snd concl); - (*Type inference*) - val (inst_cs' :: eqns_cs' :: css', ctxt') = - (fold_burrow o fold_burrow) check (inst_cs :: eqns_cs :: elem_css @ [concl_cs]) ctxt; - val (elem_css', [concl_cs']) = chop (length elem_css) css'; - in - ((map restore_inst (insts ~~ inst_cs'), - map restore_eqns (eqnss ~~ eqns_cs'), - map restore_elem (elems ~~ elem_css'), - map fst concl ~~ concl_cs'), ctxt') - end - -fun prep_full_context_statement - parse_typ parse_prop - prep_obtains prep_var_elem prep_inst prep_eqns prep_attr prep_var_inst prep_expr - {strict, do_close, fixed_frees} raw_import init_body raw_elems raw_stmt - ctxt1 - = - let - val thy = Proof_Context.theory_of ctxt1 - val (raw_insts, fixed) = parameters_of thy strict (apfst (prep_expr thy) raw_import) - fun prep_insts_cumulative (loc, (prfx, (inst, eqns))) (i, insts, eqnss, ctxt) = - let - val params = map #1 (Locale.params_of thy loc) - val inst' = prep_inst ctxt (map #1 params) inst - val parm_types' = - params |> map (#2 #> Logic.varifyT_global #> - Term.map_type_tvar (fn ((x, _), S) => TVar ((x, i), S)) #> - Type_Infer.paramify_vars) - val inst'' = map2 Type.constraint parm_types' inst' - val insts' = insts @ [(loc, (prfx, inst''))] - val ((insts'', _, _, _), ctxt2) = check_autofix insts' [] [] [] ctxt - val inst''' = insts'' |> List.last |> snd |> snd - val (inst_morph, _) = inst_morphism params (prfx, inst''') ctxt - val ctxt' = Locale.activate_declarations (loc, inst_morph) ctxt2 - handle ERROR msg => if null eqns then error msg else - (Locale.tracing ctxt1 - (msg ^ "\nFalling back to reading rewrites clause before activation."); - ctxt2) - val attrss = map (apsnd (map (prep_attr ctxt)) o fst) eqns - val eqns' = (prep_eqns ctxt' o map snd) eqns - val eqnss' = [attrss ~~ eqns'] - val ((_, [eqns''], _, _), _) = check_autofix insts'' eqnss' [] [] ctxt' - val rewrite_morph = eqns' - |> map (abs_def ctxt') - |> Variable.export_terms ctxt' ctxt - |> Element.eq_term_morphism (Proof_Context.theory_of ctxt) - |> the_default Morphism.identity - val ctxt'' = Locale.activate_declarations (loc, inst_morph $> rewrite_morph) ctxt - val eqnss' = eqnss @ [attrss ~~ Variable.export_terms ctxt' ctxt eqns'] - in (i + 1, insts', eqnss', ctxt'') end - - fun prep_elem raw_elem ctxt = - let - val ctxt' = ctxt - |> Context_Position.set_visible false - |> declare_elem prep_var_elem raw_elem - |> Context_Position.restore_visible ctxt - val elems' = parse_elem parse_typ parse_prop ctxt' raw_elem - in (elems', ctxt') end - - val fors = fold_map prep_var_inst fixed ctxt1 |> fst - val ctxt2 = ctxt1 |> Proof_Context.add_fixes fors |> snd - val (_, insts', eqnss', ctxt3) = fold prep_insts_cumulative raw_insts (0, [], [], ctxt2) - - fun prep_stmt elems ctxt = - check_autofix insts' [] elems (prepare_stmt parse_prop prep_obtains ctxt raw_stmt) ctxt - - val _ = - if fixed_frees then () - else - (case fold (fold (Variable.add_frees ctxt3) o snd o snd) insts' [] of - [] => () - | frees => error ("Illegal free variables in expression: " ^ - commas_quote (map (Syntax.string_of_term ctxt3 o Free) (rev frees)))) - - val ((insts, _, elems', concl), ctxt4) = ctxt3 - |> init_body - |> fold_map prep_elem raw_elems - |-> prep_stmt - - (*parameters from expression and elements*) - val xs = maps (fn Element.Fixes fixes => map (Variable.check_name o #1) fixes | _ => []) - (Element.Fixes fors :: elems') - val (parms, ctxt5) = fold_map Proof_Context.inferred_param xs ctxt4 - val fors' = finish_fixes parms fors - val fixed = map (fn (b, SOME T, mx) => ((Binding.name_of b, T), mx)) fors' - val deps = map (finish_inst ctxt5) insts - val elems'' = map (finish_elem (ctxt1, ctxt5) parms do_close) elems' - in ((fixed, deps, eqnss', elems'', concl), (parms, ctxt5)) end - -fun prep_inst prep_term ctxt parms (Expression.Positional insts) = - (insts ~~ parms) |> map - (fn (NONE, p) => Free (p, dummyT) - | (SOME t, _) => prep_term ctxt t) - | prep_inst prep_term ctxt parms (Expression.Named insts) = - parms |> map (fn p => - (case AList.lookup (op =) insts p of - SOME t => prep_term ctxt t | - NONE => Free (p, dummyT))) -fun parse_inst x = prep_inst Syntax.parse_term x -fun check_expr thy instances = map (apfst (Locale.check thy)) instances - -val read_full_context_statement = prep_full_context_statement - Syntax.parse_typ Syntax.parse_prop Obtain.parse_obtains - Proof_Context.read_var parse_inst Syntax.read_props Attrib.check_src - Proof_Context.read_var check_expr - -fun prep_statement prep activate raw_elems raw_stmt ctxt = - let - val ((_, _, _, elems, concl), _) = - prep {strict = true, do_close = false, fixed_frees = true} - ([], []) I raw_elems raw_stmt ctxt; - val ctxt' = ctxt - |> Proof_Context.set_stmt true - |> fold_map activate elems |> #2 - |> Proof_Context.restore_stmt ctxt; - in (concl, ctxt') end - -fun activate_i elem ctxt = - let - val elem' = - (case (Element.map_ctxt_attrib o map) Token.init_assignable elem of - Element.Defines defs => - Element.Defines (defs |> map (fn ((a, atts), (t, ps)) => - ((Thm.def_binding_optional - (Binding.name (#1 (#1 (Local_Defs.cert_def ctxt (K []) t)))) a, atts), - (t, ps)))) - | Element.Assumes assms => Element.Assumes (elaborate ctxt assms) - | e => e); - val ctxt' = Context.proof_map (Element.init elem') ctxt; - in ((Element.map_ctxt_attrib o map) Token.closure elem', ctxt') end - -fun activate raw_elem ctxt = - let val elem = raw_elem |> Element.map_ctxt - {binding = I, - typ = I, - term = I, - pattern = I, - fact = Proof_Context.get_fact ctxt, - attrib = Attrib.check_src ctxt} - in activate_i elem ctxt end - -in - -val read_goal_statement = prep_statement read_full_context_statement activate - -end - - -(* Proof assumption command *) - -local - -val structured_statement = - Parse_Spec.statement -- Parse_Spec.if_statement' -- Parse.for_fixes - >> (fn ((shows, assumes), fixes) => (fixes, assumes, shows)) - -in - -val _ = Outer_Syntax.command \<^command_keyword>\assuming\ "elaborated assumption" - (structured_statement >> (fn (a, b, c) => Toplevel.proof (fn state => - let - val ctxt = Proof.context_of state - - fun read_option_typ NONE = NONE - | read_option_typ (SOME s) = SOME (Syntax.read_typ ctxt s) - fun read_terms (s, ss) = - let val f = Syntax.read_term ctxt in (f s, map f ss) end - - val a' = map (fn (b, s, m) => (b, read_option_typ s, m)) a - val b' = map (map read_terms) b - val c' = c |> map (fn ((b, atts), ss) => - ((b, map (Attrib.attribute_cmd ctxt) atts), map read_terms ss)) - val c'' = elaborate ctxt c' - in Proof.assume a' b' c'' state end))) - -end - - -end \ No newline at end of file diff --git a/spartan/core/elaborated_statement.ML b/spartan/core/elaborated_statement.ML new file mode 100644 index 0000000..81f4a7d --- /dev/null +++ b/spartan/core/elaborated_statement.ML @@ -0,0 +1,441 @@ +(* Title: elaborated_statement.ML + Author: Joshua Chen + +Term elaboration for goal statements and proof commands. + +Contains code from parts of + ~~/Pure/Isar/element.ML and + ~~/Pure/Isar/expression.ML +in both verbatim and modified forms. +*) + +structure Elaborated_Statement: sig + +val read_goal_statement: + (string, string, Facts.ref) Element.ctxt list -> + (string, string) Element.stmt -> + Proof.context -> + (Attrib.binding * (term * term list) list) list * Proof.context + +end = struct + + +(* Elaborated goal statements *) + +local + +fun mk_type T = (Logic.mk_type T, []) +fun mk_term t = (t, []) +fun mk_propp (p, pats) = (Type.constraint propT p, pats) + +fun dest_type (T, []) = Logic.dest_type T +fun dest_term (t, []) = t +fun dest_propp (p, pats) = (p, pats) + +fun extract_inst (_, (_, ts)) = map mk_term ts +fun restore_inst ((l, (p, _)), cs) = (l, (p, map dest_term cs)) + +fun extract_eqns es = map (mk_term o snd) es +fun restore_eqns (es, cs) = map2 (fn (b, _) => fn c => (b, dest_term c)) es cs + +fun extract_elem (Element.Fixes fixes) = map (#2 #> the_list #> map mk_type) fixes + | extract_elem (Element.Constrains csts) = map (#2 #> single #> map mk_type) csts + | extract_elem (Element.Assumes asms) = map (#2 #> map mk_propp) asms + | extract_elem (Element.Defines defs) = map (fn (_, (t, ps)) => [mk_propp (t, ps)]) defs + | extract_elem (Element.Notes _) = [] + | extract_elem (Element.Lazy_Notes _) = [] + +fun restore_elem (Element.Fixes fixes, css) = + (fixes ~~ css) |> map (fn ((x, _, mx), cs) => + (x, cs |> map dest_type |> try hd, mx)) |> Element.Fixes + | restore_elem (Element.Constrains csts, css) = + (csts ~~ css) |> map (fn ((x, _), cs) => + (x, cs |> map dest_type |> hd)) |> Element.Constrains + | restore_elem (Element.Assumes asms, css) = + (asms ~~ css) |> map (fn ((b, _), cs) => (b, map dest_propp cs)) |> Element.Assumes + | restore_elem (Element.Defines defs, css) = + (defs ~~ css) |> map (fn ((b, _), [c]) => (b, dest_propp c)) |> Element.Defines + | restore_elem (elem as Element.Notes _, _) = elem + | restore_elem (elem as Element.Lazy_Notes _, _) = elem + +fun prep (_, pats) (ctxt, t :: ts) = + let val ctxt' = Proof_Context.augment t ctxt + in + ((t, Syntax.check_props + (Proof_Context.set_mode Proof_Context.mode_pattern ctxt') pats), + (ctxt', ts)) + end + +fun check cs ctxt = + let + val (cs', (ctxt', _)) = fold_map prep cs + (ctxt, Syntax.check_terms + (Proof_Context.set_mode Proof_Context.mode_schematic ctxt) (map fst cs)) + in (cs', ctxt') end + +fun inst_morphism params ((prfx, mandatory), insts') ctxt = + let + (*parameters*) + val parm_types = map #2 params; + val type_parms = fold Term.add_tfreesT parm_types []; + + (*type inference*) + val parm_types' = map (Type_Infer.paramify_vars o Logic.varifyT_global) parm_types; + val type_parms' = fold Term.add_tvarsT parm_types' []; + val checked = + (map (Logic.mk_type o TVar) type_parms' @ map2 Type.constraint parm_types' insts') + |> Syntax.check_terms (Config.put Type_Infer.object_logic false ctxt) + val (type_parms'', insts'') = chop (length type_parms') checked; + + (*context*) + val ctxt' = fold Proof_Context.augment checked ctxt; + val certT = Thm.trim_context_ctyp o Thm.ctyp_of ctxt'; + val cert = Thm.trim_context_cterm o Thm.cterm_of ctxt'; + + (*instantiation*) + val instT = + (type_parms ~~ map Logic.dest_type type_parms'') + |> map_filter (fn (v, T) => if TFree v = T then NONE else SOME (v, T)); + val cert_inst = + ((map #1 params ~~ map (Term_Subst.instantiateT_frees instT) parm_types) ~~ insts'') + |> map_filter (fn (v, t) => if Free v = t then NONE else SOME (v, cert t)); + in + (Element.instantiate_normalize_morphism (map (apsnd certT) instT, cert_inst) $> + Morphism.binding_morphism "Expression.inst" (Binding.prefix mandatory prfx), ctxt') + end; + +fun abs_def ctxt = + Thm.cterm_of ctxt #> Assumption.assume ctxt #> Local_Defs.abs_def_rule ctxt #> Thm.prop_of; + +fun declare_elem prep_var (Element.Fixes fixes) ctxt = + let val (vars, _) = fold_map prep_var fixes ctxt + in ctxt |> Proof_Context.add_fixes vars |> snd end + | declare_elem prep_var (Element.Constrains csts) ctxt = + ctxt |> fold_map (fn (x, T) => prep_var (Binding.name x, SOME T, NoSyn)) csts |> snd + | declare_elem _ (Element.Assumes _) ctxt = ctxt + | declare_elem _ (Element.Defines _) ctxt = ctxt + | declare_elem _ (Element.Notes _) ctxt = ctxt + | declare_elem _ (Element.Lazy_Notes _) ctxt = ctxt; + +fun parameters_of thy strict (expr, fixed) = + let + val ctxt = Proof_Context.init_global thy; + + fun reject_dups message xs = + (case duplicates (op =) xs of + [] => () + | dups => error (message ^ commas dups)); + + fun parm_eq ((p1, mx1), (p2, mx2)) = + p1 = p2 andalso + (Mixfix.equal (mx1, mx2) orelse + error ("Conflicting syntax for parameter " ^ quote p1 ^ " in expression" ^ + Position.here_list [Mixfix.pos_of mx1, Mixfix.pos_of mx2])); + + fun params_loc loc = Locale.params_of thy loc |> map (apfst #1); + fun params_inst (loc, (prfx, (Expression.Positional insts, eqns))) = + let + val ps = params_loc loc; + val d = length ps - length insts; + val insts' = + if d < 0 then + error ("More arguments than parameters in instantiation of locale " ^ + quote (Locale.markup_name ctxt loc)) + else insts @ replicate d NONE; + val ps' = (ps ~~ insts') |> + map_filter (fn (p, NONE) => SOME p | (_, SOME _) => NONE); + in (ps', (loc, (prfx, (Expression.Positional insts', eqns)))) end + | params_inst (loc, (prfx, (Expression.Named insts, eqns))) = + let + val _ = + reject_dups "Duplicate instantiation of the following parameter(s): " + (map fst insts); + val ps' = (insts, params_loc loc) |-> fold (fn (p, _) => fn ps => + if AList.defined (op =) ps p then AList.delete (op =) p ps + else error (quote p ^ " not a parameter of instantiated expression")); + in (ps', (loc, (prfx, (Expression.Named insts, eqns)))) end; + fun params_expr is = + let + val (is', ps') = fold_map (fn i => fn ps => + let + val (ps', i') = params_inst i; + val ps'' = distinct parm_eq (ps @ ps'); + in (i', ps'') end) is [] + in (ps', is') end; + + val (implicit, expr') = params_expr expr; + + val implicit' = map #1 implicit; + val fixed' = map (Variable.check_name o #1) fixed; + val _ = reject_dups "Duplicate fixed parameter(s): " fixed'; + val implicit'' = + if strict then [] + else + let + val _ = + reject_dups + "Parameter(s) declared simultaneously in expression and for clause: " + (implicit' @ fixed'); + in map (fn (x, mx) => (Binding.name x, NONE, mx)) implicit end; + in (expr', implicit'' @ fixed) end; + +fun parse_elem prep_typ prep_term ctxt = + Element.map_ctxt + {binding = I, + typ = prep_typ ctxt, + term = prep_term (Proof_Context.set_mode Proof_Context.mode_schematic ctxt), + pattern = prep_term (Proof_Context.set_mode Proof_Context.mode_pattern ctxt), + fact = I, + attrib = I}; + +fun prepare_stmt prep_prop prep_obtains ctxt stmt = + (case stmt of + Element.Shows raw_shows => + raw_shows |> (map o apsnd o map) (fn (t, ps) => + (prep_prop (Proof_Context.set_mode Proof_Context.mode_schematic ctxt) t, + map (prep_prop (Proof_Context.set_mode Proof_Context.mode_pattern ctxt)) ps)) + | Element.Obtains raw_obtains => + let + val ((_, thesis), thesis_ctxt) = Obtain.obtain_thesis ctxt; + val obtains = prep_obtains thesis_ctxt thesis raw_obtains; + in map (fn (b, t) => ((b, []), [(t, [])])) obtains end); + +fun finish_fixes (parms: (string * typ) list) = map (fn (binding, _, mx) => + let val x = Binding.name_of binding + in (binding, AList.lookup (op =) parms x, mx) end) + +fun finish_inst ctxt (loc, (prfx, inst)) = + let + val thy = Proof_Context.theory_of ctxt; + val (morph, _) = inst_morphism (map #1 (Locale.params_of thy loc)) (prfx, inst) ctxt; + in (loc, morph) end + +fun closeup _ _ false elem = elem + | closeup (outer_ctxt, ctxt) parms true elem = + let + (*FIXME consider closing in syntactic phase -- before type checking*) + fun close_frees t = + let + val rev_frees = + Term.fold_aterms (fn Free (x, T) => + if Variable.is_fixed outer_ctxt x orelse AList.defined (op =) parms x then I + else insert (op =) (x, T) | _ => I) t []; + in fold (Logic.all o Free) rev_frees t end; + + fun no_binds [] = [] + | no_binds _ = error "Illegal term bindings in context element"; + in + (case elem of + Element.Assumes asms => Element.Assumes (asms |> map (fn (a, propps) => + (a, map (fn (t, ps) => (close_frees t, no_binds ps)) propps))) + | Element.Defines defs => Element.Defines (defs |> map (fn ((name, atts), (t, ps)) => + let val ((c, _), t') = Local_Defs.cert_def ctxt (K []) (close_frees t) + in ((Thm.def_binding_optional (Binding.name c) name, atts), (t', no_binds ps)) end)) + | e => e) + end + +fun finish_elem _ parms _ (Element.Fixes fixes) = Element.Fixes (finish_fixes parms fixes) + | finish_elem _ _ _ (Element.Constrains _) = Element.Constrains [] + | finish_elem ctxts parms do_close (Element.Assumes asms) = closeup ctxts parms do_close (Element.Assumes asms) + | finish_elem ctxts parms do_close (Element.Defines defs) = closeup ctxts parms do_close (Element.Defines defs) + | finish_elem _ _ _ (elem as Element.Notes _) = elem + | finish_elem _ _ _ (elem as Element.Lazy_Notes _) = elem + +fun check_autofix insts eqnss elems concl ctxt = + let + val inst_cs = map extract_inst insts; + val eqns_cs = map extract_eqns eqnss; + val elem_css = map extract_elem elems; + val concl_cs = (map o map) mk_propp (map snd concl); + (*Type inference*) + val (inst_cs' :: eqns_cs' :: css', ctxt') = + (fold_burrow o fold_burrow) check (inst_cs :: eqns_cs :: elem_css @ [concl_cs]) ctxt; + val (elem_css', [concl_cs']) = chop (length elem_css) css'; + in + ((map restore_inst (insts ~~ inst_cs'), + map restore_eqns (eqnss ~~ eqns_cs'), + map restore_elem (elems ~~ elem_css'), + map fst concl ~~ concl_cs'), ctxt') + end + +fun prep_full_context_statement + parse_typ parse_prop + prep_obtains prep_var_elem prep_inst prep_eqns prep_attr prep_var_inst prep_expr + {strict, do_close, fixed_frees} raw_import init_body raw_elems raw_stmt + ctxt1 + = + let + val thy = Proof_Context.theory_of ctxt1 + val (raw_insts, fixed) = parameters_of thy strict (apfst (prep_expr thy) raw_import) + fun prep_insts_cumulative (loc, (prfx, (inst, eqns))) (i, insts, eqnss, ctxt) = + let + val params = map #1 (Locale.params_of thy loc) + val inst' = prep_inst ctxt (map #1 params) inst + val parm_types' = + params |> map (#2 #> Logic.varifyT_global #> + Term.map_type_tvar (fn ((x, _), S) => TVar ((x, i), S)) #> + Type_Infer.paramify_vars) + val inst'' = map2 Type.constraint parm_types' inst' + val insts' = insts @ [(loc, (prfx, inst''))] + val ((insts'', _, _, _), ctxt2) = check_autofix insts' [] [] [] ctxt + val inst''' = insts'' |> List.last |> snd |> snd + val (inst_morph, _) = inst_morphism params (prfx, inst''') ctxt + val ctxt' = Locale.activate_declarations (loc, inst_morph) ctxt2 + handle ERROR msg => if null eqns then error msg else + (Locale.tracing ctxt1 + (msg ^ "\nFalling back to reading rewrites clause before activation."); + ctxt2) + val attrss = map (apsnd (map (prep_attr ctxt)) o fst) eqns + val eqns' = (prep_eqns ctxt' o map snd) eqns + val eqnss' = [attrss ~~ eqns'] + val ((_, [eqns''], _, _), _) = check_autofix insts'' eqnss' [] [] ctxt' + val rewrite_morph = eqns' + |> map (abs_def ctxt') + |> Variable.export_terms ctxt' ctxt + |> Element.eq_term_morphism (Proof_Context.theory_of ctxt) + |> the_default Morphism.identity + val ctxt'' = Locale.activate_declarations (loc, inst_morph $> rewrite_morph) ctxt + val eqnss' = eqnss @ [attrss ~~ Variable.export_terms ctxt' ctxt eqns'] + in (i + 1, insts', eqnss', ctxt'') end + + fun prep_elem raw_elem ctxt = + let + val ctxt' = ctxt + |> Context_Position.set_visible false + |> declare_elem prep_var_elem raw_elem + |> Context_Position.restore_visible ctxt + val elems' = parse_elem parse_typ parse_prop ctxt' raw_elem + in (elems', ctxt') end + + val fors = fold_map prep_var_inst fixed ctxt1 |> fst + val ctxt2 = ctxt1 |> Proof_Context.add_fixes fors |> snd + val (_, insts', eqnss', ctxt3) = fold prep_insts_cumulative raw_insts (0, [], [], ctxt2) + + fun prep_stmt elems ctxt = + check_autofix insts' [] elems (prepare_stmt parse_prop prep_obtains ctxt raw_stmt) ctxt + + val _ = + if fixed_frees then () + else + (case fold (fold (Variable.add_frees ctxt3) o snd o snd) insts' [] of + [] => () + | frees => error ("Illegal free variables in expression: " ^ + commas_quote (map (Syntax.string_of_term ctxt3 o Free) (rev frees)))) + + val ((insts, _, elems', concl), ctxt4) = ctxt3 + |> init_body + |> fold_map prep_elem raw_elems + |-> prep_stmt + + (*parameters from expression and elements*) + val xs = maps (fn Element.Fixes fixes => map (Variable.check_name o #1) fixes | _ => []) + (Element.Fixes fors :: elems') + val (parms, ctxt5) = fold_map Proof_Context.inferred_param xs ctxt4 + val fors' = finish_fixes parms fors + val fixed = map (fn (b, SOME T, mx) => ((Binding.name_of b, T), mx)) fors' + val deps = map (finish_inst ctxt5) insts + val elems'' = map (finish_elem (ctxt1, ctxt5) parms do_close) elems' + in ((fixed, deps, eqnss', elems'', concl), (parms, ctxt5)) end + +fun prep_inst prep_term ctxt parms (Expression.Positional insts) = + (insts ~~ parms) |> map + (fn (NONE, p) => Free (p, dummyT) + | (SOME t, _) => prep_term ctxt t) + | prep_inst prep_term ctxt parms (Expression.Named insts) = + parms |> map (fn p => + (case AList.lookup (op =) insts p of + SOME t => prep_term ctxt t | + NONE => Free (p, dummyT))) +fun parse_inst x = prep_inst Syntax.parse_term x +fun check_expr thy instances = map (apfst (Locale.check thy)) instances + +val read_full_context_statement = prep_full_context_statement + Syntax.parse_typ Syntax.parse_prop Obtain.parse_obtains + Proof_Context.read_var parse_inst Syntax.read_props Attrib.check_src + Proof_Context.read_var check_expr + +fun filter_assumes ((x as Element.Assumes _) :: xs) = x :: filter_assumes xs + | filter_assumes (_ :: xs) = filter_assumes xs + | filter_assumes [] = [] + +fun prep_statement prep activate raw_elems raw_stmt ctxt = + let + val ((_, _, _, elems, concl), _) = + prep {strict = true, do_close = false, fixed_frees = true} + ([], []) I raw_elems raw_stmt ctxt + + val (elems', ctxt') = ctxt + |> Proof_Context.set_stmt true + |> fold_map activate elems + |> apsnd (Proof_Context.restore_stmt ctxt) + + val assumes = filter_assumes elems' + val assms = flat (flat (map + (fn (Element.Assumes asms) => + map (fn (_, facts) => map (Thm.cterm_of ctxt' o #1) facts) asms) + assumes)) + val concl' = Elab.elaborate ctxt' assms concl handle error => concl + in (concl', ctxt') end + +fun activate_i elem ctxt = + let + val elem' = + (case (Element.map_ctxt_attrib o map) Token.init_assignable elem of + Element.Defines defs => + Element.Defines (defs |> map (fn ((a, atts), (t, ps)) => + ((Thm.def_binding_optional + (Binding.name (#1 (#1 (Local_Defs.cert_def ctxt (K []) t)))) a, atts), + (t, ps)))) + | Element.Assumes assms => Element.Assumes (Elab.elaborate ctxt [] assms) + | e => e); + val ctxt' = Context.proof_map (Element.init elem') ctxt; + in ((Element.map_ctxt_attrib o map) Token.closure elem', ctxt') end + +fun activate raw_elem ctxt = + let val elem = raw_elem |> Element.map_ctxt + {binding = I, + typ = I, + term = I, + pattern = I, + fact = Proof_Context.get_fact ctxt, + attrib = Attrib.check_src ctxt} + in activate_i elem ctxt end + +in + +val read_goal_statement = prep_statement read_full_context_statement activate + +end + + +(* Proof assumption command *) + +local + +val structured_statement = + Parse_Spec.statement -- Parse_Spec.if_statement' -- Parse.for_fixes + >> (fn ((shows, assumes), fixes) => (fixes, assumes, shows)) + +in + +val _ = Outer_Syntax.command \<^command_keyword>\assuming\ "elaborated assumption" + (structured_statement >> (fn (a, b, c) => Toplevel.proof (fn state => + let + val ctxt = Proof.context_of state + + fun read_option_typ NONE = NONE + | read_option_typ (SOME s) = SOME (Syntax.read_typ ctxt s) + fun read_terms (s, ss) = + let val f = Syntax.read_term ctxt in (f s, map f ss) end + + val a' = map (fn (b, s, m) => (b, read_option_typ s, m)) a + val b' = map (map read_terms) b + val c' = c |> map (fn ((b, atts), ss) => + ((b, map (Attrib.attribute_cmd ctxt) atts), map read_terms ss)) + val c'' = Elab.elaborate ctxt [] c' + in Proof.assume a' b' c'' state end))) + +end + + +end \ No newline at end of file diff --git a/spartan/core/elaboration.ML b/spartan/core/elaboration.ML index 27b6bb0..9e5e0bd 100644 --- a/spartan/core/elaboration.ML +++ b/spartan/core/elaboration.ML @@ -1,13 +1,14 @@ (* Title: elaboration.ML Author: Joshua Chen -Basic elaboration. +Basic term elaboration. *) structure Elab: sig val elab: Proof.context -> cterm list -> term -> Envir.env val elab_stmt: Proof.context -> cterm list -> term -> Envir.env * term +val elaborate: Proof.context -> cterm list -> ('a * (term * term list) list) list -> ('a * (term * term list) list) list end = struct @@ -72,5 +73,19 @@ fun elab_stmt ctxt assums stmt = in (subst', subst_term subst' stmt) end end +(*Apply elaboration to the list format that assumptions and goal statements are + given in*) +fun elaborate ctxt known assms = + let + fun subst_term env = Envir.subst_term (Envir.type_env env, Envir.term_env env) + fun elab_fact (fact, xs) assums = + let val (subst, fact') = elab_stmt ctxt assums fact in + ((fact', map (subst_term subst) xs), Thm.cterm_of ctxt fact' :: assums) + end + fun elab (b, facts) assums = + let val (facts', assums') = fold_map elab_fact facts assums + in ((b, facts'), assums') end + in #1 (fold_map elab assms known) end + end diff --git a/spartan/core/focus.ML b/spartan/core/focus.ML index 1d8de78..2ad4c8a 100644 --- a/spartan/core/focus.ML +++ b/spartan/core/focus.ML @@ -1,14 +1,51 @@ (* Title: focus.ML - Author: Makarius Wenzel, Joshua Chen + Author: Joshua Chen -A modified version of the Isar `subgoal` command -that keeps schematic variables in the goal state. +Focus on head subgoal, with optional variable renaming. -Modified from code originally written by Makarius Wenzel. +Modified from code contained in ~~/Pure/Isar/subgoal.ML. *) local +fun reverse_prems imp = + let val (prems, concl) = (Drule.strip_imp_prems imp, Drule.strip_imp_concl imp) + in fold (curry mk_implies) prems concl end + +fun gen_focus ctxt i bindings raw_st = + let + val st = raw_st + |> Thm.solve_constraints + |> Thm.transfer' ctxt + |> Raw_Simplifier.norm_hhf_protect ctxt + + val ((schematic_types, [st']), ctxt1) = Variable.importT [st] ctxt + + val ((params, goal), ctxt2) = + Variable.focus_cterm bindings (Thm.cprem_of st' i) ctxt1 + + val (asms, concl) = + (Drule.strip_imp_prems goal, Drule.strip_imp_concl goal) + + fun intern_var_assms asm (asms, concl) = + if Lib.no_vars (Thm.term_of asm) + then (asm :: asms, concl) + else (asms, Drule.mk_implies (asm, concl)) + + val (asms', concl') = fold intern_var_assms asms ([], concl) + |> apfst rev |> apsnd reverse_prems + + val (inst, ctxt3) = Variable.import_inst true (map Thm.term_of (asms')) ctxt2 + val schematic_terms = map (apsnd (Thm.cterm_of ctxt3)) (#2 inst) + val schematics = (schematic_types, schematic_terms) + val asms' = map (Thm.instantiate_cterm schematics) asms' + val concl' = Thm.instantiate_cterm schematics concl' + val (prems, context) = Assumption.add_assumes asms' ctxt3 + in + ({context = context, params = params, prems = prems, + asms = asms', concl = concl', schematics = schematics}, Goal.init concl') + end + fun param_bindings ctxt (param_suffix, raw_param_specs) st = let val _ = if Thm.no_prems st then error "No subgoals!" else () @@ -24,8 +61,8 @@ fun param_bindings ctxt (param_suffix, raw_param_specs) st = error ("Excessive subgoal parameter specification" ^ Position.here_list (map snd (drop n raw_param_specs))) - val param_specs = - raw_param_specs |> map + val param_specs = raw_param_specs + |> map (fn (NONE, _) => NONE | (SOME x, pos) => let @@ -39,7 +76,7 @@ fun param_bindings ctxt (param_suffix, raw_param_specs) st = | bindings _ ys = map Binding.name ys in bindings param_specs subgoal_params end -fun gen_schematic_subgoal prep_atts raw_result_binding raw_prems_binding param_specs state = +fun gen_schematic_subgoal prep_atts raw_result_binding param_specs state = let val _ = Proof.assert_backward state @@ -47,17 +84,13 @@ fun gen_schematic_subgoal prep_atts raw_result_binding raw_prems_binding param_s |> Proof.map_context (Proof_Context.set_mode Proof_Context.mode_schematic) |> Proof.refine_insert [] - val {context = ctxt, facts = facts, goal = st} = Proof.raw_goal state1 - + val {context = ctxt, facts, goal = st} = Proof.raw_goal state1 val result_binding = apsnd (map (prep_atts ctxt)) raw_result_binding - val (prems_binding, do_prems) = - (case raw_prems_binding of - SOME (b, raw_atts) => ((b, map (prep_atts ctxt) raw_atts), true) - | NONE => (Binding.empty_atts, false)) - val (subgoal_focus, _) = - (if do_prems then Subgoal.focus_prems else Subgoal.focus_params) ctxt - 1 (SOME (param_bindings ctxt param_specs st)) st + val subgoal_focus = #1 + (gen_focus ctxt 1 (SOME (param_bindings ctxt param_specs st)) st) + + val prems = #prems subgoal_focus fun after_qed (ctxt'', [[result]]) = Proof.end_block #> (fn state' => @@ -83,31 +116,29 @@ fun gen_schematic_subgoal prep_atts raw_result_binding raw_prems_binding param_s |> Proof.begin_block |> Proof.map_context (fn _ => #context subgoal_focus - |> Proof_Context.note_thmss "" [(prems_binding, [(#prems subgoal_focus, [])])] |> #2) + |> Proof_Context.note_thmss "" [((Binding.name "prems", []), [(prems, [])])] + |> #2) |> Proof.internal_goal (K (K ())) (Proof_Context.get_mode ctxt) true "subgoal" - NONE after_qed [] [] [(Binding.empty_atts, [(Thm.term_of (#concl subgoal_focus), [])])] |> #2 - |> Proof.using_facts facts + NONE after_qed [] [] [(Binding.empty_atts, [(Thm.term_of (#concl subgoal_focus), [])])] + |> #2 + |> Proof.using_facts (facts @ prems) |> pair subgoal_focus end val opt_fact_binding = - Scan.optional (Parse.binding -- Parse.opt_attribs || Parse.attribs >> pair Binding.empty) + Scan.optional ((Parse.binding -- Parse.opt_attribs || Parse.attribs >> pair Binding.empty) --| Args.colon) Binding.empty_atts -val for_params = - Scan.optional - (\<^keyword>\vars\ |-- - Parse.!!! ((Scan.option Parse.dots >> is_some) -- - (Scan.repeat1 (Parse.maybe_position Parse.name_position)))) - (false, []) +val for_params = Scan.optional + (\<^keyword>\vars\ |-- + Parse.!!! ((Scan.option Parse.dots >> is_some) -- + (Scan.repeat1 (Parse.maybe_position Parse.name_position)))) + (false, []) val schematic_subgoal_cmd = gen_schematic_subgoal Attrib.attribute_cmd -val parser = - opt_fact_binding - -- (Scan.option (\<^keyword>\prems\ |-- Parse.!!! opt_fact_binding)) - -- for_params >> (fn ((a, b), c) => - Toplevel.proofs (Seq.make_results o Seq.single o #2 o schematic_subgoal_cmd a b c)) +val parser = opt_fact_binding -- for_params >> (fn (fact, params) => + Toplevel.proofs (Seq.make_results o Seq.single o #2 o schematic_subgoal_cmd fact params)) in @@ -117,9 +148,10 @@ val _ = Outer_Syntax.command \<^command_keyword>\focus\ "focus on first subgoal within backward refinement, without instantiating schematic vars" parser -val _ = Outer_Syntax.command \<^command_keyword>\\\ "focus bullet" parser val _ = Outer_Syntax.command \<^command_keyword>\\<^item>\ "focus bullet" parser val _ = Outer_Syntax.command \<^command_keyword>\\<^enum>\ "focus bullet" parser +val _ = Outer_Syntax.command \<^command_keyword>\\\ "focus bullet" parser +val _ = Outer_Syntax.command \<^command_keyword>\\\ "focus bullet" parser val _ = Outer_Syntax.command \<^command_keyword>\~\ "focus bullet" parser end diff --git a/spartan/core/goals.ML b/spartan/core/goals.ML index 87ec2b8..540f5c7 100644 --- a/spartan/core/goals.ML +++ b/spartan/core/goals.ML @@ -1,9 +1,9 @@ (* Title: goals.ML - Author: Makarius Wenzel, Joshua Chen + Author: Joshua Chen Goal statements and proof term export. -Modified from code originally written by Makarius Wenzel. +Modified from code contained in ~~/Pure/Isar/specification.ML. *) local @@ -184,15 +184,15 @@ val schematic_theorem_cmd = gen_schematic_theorem Bundle.includes_cmd Attrib.check_src - Elaborated_Assumption.read_goal_statement + Elaborated_Statement.read_goal_statement fun theorem spec descr = Outer_Syntax.local_theory_to_proof' spec ("state " ^ descr) - ( Scan.option (Args.parens (Args.$$$ "derive")) + ( Scan.option (Args.parens (Args.$$$ "def")) -- (long_statement || short_statement) >> (fn (opt_derive, (long, binding, includes, elems, concl)) => schematic_theorem_cmd - (case opt_derive of SOME "derive" => true | _ => false) + (case opt_derive of SOME "def" => true | _ => false) long descr NONE (K I) binding includes elems concl) ) fun definition spec descr = diff --git a/spartan/core/tactics.ML b/spartan/core/tactics.ML index 3922ae0..19d3d71 100644 --- a/spartan/core/tactics.ML +++ b/spartan/core/tactics.ML @@ -19,8 +19,7 @@ end = struct (* Side conditions *) -val solve_side_conds = - Attrib.setup_config_int \<^binding>\solve_side_conds\ (K 2) +val solve_side_conds = Attrib.setup_config_int \<^binding>\solve_side_conds\ (K 2) fun SIDE_CONDS ctac facts i (cst as (ctxt, st)) = cst |> (ctac i CTHEN (case Config.get ctxt solve_side_conds of diff --git a/spartan/core/typechecking.ML b/spartan/core/typechecking.ML index 57164a1..a6e1726 100644 --- a/spartan/core/typechecking.ML +++ b/spartan/core/typechecking.ML @@ -51,10 +51,9 @@ fun known_ctac facts = CONTEXT_SUBGOAL (fn (goal, i) => fn (ctxt, st) => if Lib.no_vars concl orelse (Lib.is_typing concl andalso Lib.no_vars (Lib.term_of_typing concl)) then - let val ths = facts + let val ths = map (Simplifier.norm_hhf ctxt) + (facts @ map fst (Facts.props (Proof_Context.facts_of ctxt))) (*FIXME: Shouldn't pull nameless facts directly from context*) - @ map fst (Facts.props (Proof_Context.facts_of ctxt)) - |> map (Simplifier.norm_hhf ctxt) in (debug_tac ctxt "resolve" THEN resolve_tac ctxt ths i ORELSE debug_tac ctxt "assume" THEN assume_tac ctxt i) st @@ -70,7 +69,8 @@ fun check_infer_step facts i (ctxt, st) = val tac = SUBGOAL (fn (goal, i) => if Lib.rigid_typing_concl goal then - let val net = Tactic.build_net (facts + let val net = Tactic.build_net ( + map (Simplifier.norm_hhf ctxt) facts (*MAYBE FIXME: Remove `typechk` from this list, and instead perform definitional unfolding to (w?)hnf.*) @(Named_Theorems.get ctxt \<^named_theorems>\typechk\) -- cgit v1.2.3