end else
FreshNamesGenerator.mk_fresh_name ~subst:[] metasenv context name ~typ
-let tactic_of_ast status ast =
+let rec tactic_of_ast status ast =
let module PET = ProofEngineTypes in
match ast with
+ (* Higher order tactics *)
+ | GrafiteAst.Do (loc, n, tactic) ->
+ Tacticals.do_tactic n (tactic_of_ast status tactic)
+ | GrafiteAst.Seq (loc, tactics) -> (* tac1; tac2; ... *)
+ Tacticals.seq (List.map (tactic_of_ast status) tactics)
+ | GrafiteAst.Repeat (loc, tactic) ->
+ Tacticals.repeat_tactic (tactic_of_ast status tactic)
+ | GrafiteAst.Then (loc, tactic, tactics) -> (* tac; [ tac1 | ... ] *)
+ Tacticals.thens
+ (tactic_of_ast status tactic)
+ (List.map (tactic_of_ast status) tactics)
+ | GrafiteAst.First (loc, tactics) ->
+ Tacticals.first (List.map (tactic_of_ast status) tactics)
+ | GrafiteAst.Try (loc, tactic) ->
+ Tacticals.try_tactic (tactic_of_ast status tactic)
+ | GrafiteAst.Solve (loc, tactics) ->
+ Tacticals.solve_tactics (List.map (tactic_of_ast status) tactics)
+ | GrafiteAst.Progress (loc, tactic) ->
+ Tacticals.progress_tactic (tactic_of_ast status tactic)
+ (* First order tactics *)
| GrafiteAst.Absurd (_, term) -> Tactics.absurd term
| GrafiteAst.Apply (_, term) -> Tactics.apply term
| GrafiteAst.ApplyS (_, term, params) ->
| GrafiteAst.Cut (_, ident, term) ->
let names = match ident with None -> [] | Some id -> [id] in
Tactics.cut ~mk_fresh_name_callback:(namer_of names) term
- | GrafiteAst.Decompose (_, types, what, names) ->
- let to_type = function
- | GrafiteAst.Type (uri, typeno) -> uri, Some typeno
- | GrafiteAst.Ident _ -> assert false
- in
- let user_types = List.rev_map to_type types in
- let dbd = LibraryDb.instance () in
+ | GrafiteAst.Decompose (_, names) ->
let mk_fresh_name_callback = namer_of names in
- Tactics.decompose ~mk_fresh_name_callback ~dbd ~user_types ?what
+ Tactics.decompose ~mk_fresh_name_callback ()
| GrafiteAst.Demodulate _ ->
Tactics.demodulate
~dbd:(LibraryDb.instance ()) ~universe:status.GrafiteTypes.universe
| GrafiteAst.Destruct (_,term) -> Tactics.destruct term
- | GrafiteAst.Elim (_, what, using, depth, names) ->
+ | GrafiteAst.Elim (_, what, using, pattern, depth, names) ->
Tactics.elim_intros ?using ?depth ~mk_fresh_name_callback:(namer_of names)
- what
+ ~pattern what
| GrafiteAst.ElimType (_, what, using, depth, names) ->
Tactics.elim_type ?using ?depth ~mk_fresh_name_callback:(namer_of names)
what
| GrafiteAst.Generalize (_,pattern,ident) ->
let names = match ident with None -> [] | Some id -> [id] in
Tactics.generalize ~mk_fresh_name_callback:(namer_of names) pattern
- | GrafiteAst.Goal (_, n) -> Tactics.set_goal n
| GrafiteAst.IdTac _ -> Tactics.id
| GrafiteAst.Intros (_, None, names) ->
PrimitiveTactics.intros_tac ~mk_fresh_name_callback:(namer_of names) ()
| GrafiteAst.Reflexivity _ -> Tactics.reflexivity
| GrafiteAst.Replace (_, pattern, with_what) ->
Tactics.replace ~pattern ~with_what
- | GrafiteAst.Rewrite (_, direction, t, pattern) ->
- EqualityTactics.rewrite_tac ~direction ~pattern t
+ | GrafiteAst.Rewrite (_, direction, t, pattern, names) ->
+ EqualityTactics.rewrite_tac ~direction ~pattern t names
| GrafiteAst.Right _ -> Tactics.right
| GrafiteAst.Ring _ -> Tactics.ring
| GrafiteAst.Split _ -> Tactics.split
| GrafiteAst.Byinduction (_, t, id) -> Declarative.byinduction t id
| GrafiteAst.Thesisbecomes (_, t) -> Declarative.thesisbecomes t
| GrafiteAst.ExistsElim (_, t, id1, t1, id2, t2) ->
- Declarative.existselim t id1 t1 id2 t2
+ Declarative.existselim ~dbd:(LibraryDb.instance())
+ ~universe:status.GrafiteTypes.universe t id1 t1 id2 t2
| GrafiteAst.Case (_,id,params) -> Declarative.case id params
| GrafiteAst.AndElim(_,t,id1,t1,id2,t2) -> Declarative.andelim t id1 t1 id2 t2
| GrafiteAst.RewritingStep (_,termine,t1,t2,cont) ->
| GrafiteAst.Generalize _
| GrafiteAst.Elim _
| GrafiteAst.Cut _
- | GrafiteAst.Decompose _ -> true, true
- (* tactics we don't want to reorder goals. I think only Goal needs this. *)
- | GrafiteAst.Goal _ -> false, true
+ | GrafiteAst.Decompose _ -> true
(* tactics like apply *)
- | _ -> true, false
+ | _ -> false
let reorder_metasenv start refine tactic goals current_goal always_opens_a_goal=
let module PEH = ProofEngineHelpers in
before @ produced_metas @ after, goals
let apply_tactic ~disambiguate_tactic (text,prefix_len,tactic) (status, goal) =
-(* prerr_endline "apply_tactic"; *)
-(* prerr_endline (Continuationals.Stack.pp (GrafiteTypes.get_stack status)); *)
let starting_metasenv = GrafiteTypes.get_proof_metasenv status in
let before = List.map (fun g, _, _ -> g) starting_metasenv in
-(* prerr_endline "disambiguate"; *)
let status, tactic = disambiguate_tactic status goal (text,prefix_len,tactic) in
let metasenv_after_refinement = GrafiteTypes.get_proof_metasenv status in
let proof = GrafiteTypes.get_current_proof status in
let proof_status = proof, goal in
- let needs_reordering, always_opens_a_goal = classify_tactic tactic in
+ let always_opens_a_goal = classify_tactic tactic in
let tactic = tactic_of_ast status tactic in
- (* apply tactic will change the lexicon_status ... *)
-(* prerr_endline "apply_tactic bassa"; *)
let (proof, opened) = ProofEngineTypes.apply_tactic tactic proof_status in
let after = ProofEngineTypes.goals_of_proof proof in
let opened_goals, closed_goals = Tacticals.goals_diff ~before ~after ~opened in
-(* prerr_endline("before: " ^ String.concat ", " (List.map string_of_int before));
-prerr_endline("after: " ^ String.concat ", " (List.map string_of_int after));
-prerr_endline("opened: " ^ String.concat ", " (List.map string_of_int opened)); *)
-(* prerr_endline("opened_goals: " ^ String.concat ", " (List.map string_of_int opened_goals));
-prerr_endline("closed_goals: " ^ String.concat ", " (List.map string_of_int closed_goals)); *)
let proof, opened_goals =
- if needs_reordering then begin
- let uri, metasenv_after_tactic, t, ty = proof in
-(* prerr_endline ("goal prima del riordino: " ^ String.concat " " (List.map string_of_int (ProofEngineTypes.goals_of_proof proof))); *)
- let reordered_metasenv, opened_goals =
- reorder_metasenv
- starting_metasenv
- metasenv_after_refinement metasenv_after_tactic
- opened goal always_opens_a_goal
- in
- let proof' = uri, reordered_metasenv, t, ty in
-(* prerr_endline ("goal dopo il riordino: " ^ String.concat " " (List.map string_of_int (ProofEngineTypes.goals_of_proof proof'))); *)
- proof', opened_goals
- end
- else
- proof, opened_goals
+ let uri, metasenv_after_tactic, t, ty, attrs = proof in
+ let reordered_metasenv, opened_goals =
+ reorder_metasenv
+ starting_metasenv
+ metasenv_after_refinement metasenv_after_tactic
+ opened goal always_opens_a_goal
+ in
+ let proof' = uri, reordered_metasenv, t, ty, attrs in
+ proof', opened_goals
in
let incomplete_proof =
match status.GrafiteTypes.proof_status with
{ incomplete_proof with GrafiteTypes.proof = proof } },
opened_goals, closed_goals
+let apply_atomic_tactical ~disambiguate_tactic ~patch (text,prefix_len,tactic) (status, goal) =
+ let starting_metasenv = GrafiteTypes.get_proof_metasenv status in
+ let before = List.map (fun g, _, _ -> g) starting_metasenv in
+ let status, tactic = disambiguate_tactic status goal (text,prefix_len,tactic) in
+ let metasenv_after_refinement = GrafiteTypes.get_proof_metasenv status in
+ let proof = GrafiteTypes.get_current_proof status in
+ let proof_status = proof, goal in
+ let always_opens_a_goal = classify_tactic tactic in
+ let tactic = tactic_of_ast status tactic in
+ let tactic = patch tactic in
+ let (proof, opened) = ProofEngineTypes.apply_tactic tactic proof_status in
+ let after = ProofEngineTypes.goals_of_proof proof in
+ let opened_goals, closed_goals = Tacticals.goals_diff ~before ~after ~opened in
+ let proof, opened_goals =
+ let uri, metasenv_after_tactic, t, ty, attrs = proof in
+ let reordered_metasenv, opened_goals =
+ reorder_metasenv
+ starting_metasenv
+ metasenv_after_refinement metasenv_after_tactic
+ opened goal always_opens_a_goal
+ in
+ let proof' = uri, reordered_metasenv, t, ty, attrs in
+ proof', opened_goals
+ in
+ let incomplete_proof =
+ match status.GrafiteTypes.proof_status with
+ | GrafiteTypes.Incomplete_proof p -> p
+ | _ -> assert false
+ in
+ { status with GrafiteTypes.proof_status =
+ GrafiteTypes.Incomplete_proof
+ { incomplete_proof with GrafiteTypes.proof = proof } },
+ opened_goals, closed_goals
type eval_ast =
{ea_go:
'term 'lazy_term 'reduction 'obj 'ident.
type 'a eval_from_moo =
{ efm_go: GrafiteTypes.status -> string -> GrafiteTypes.status }
-let coercion_moo_statement_of arity uri =
+let coercion_moo_statement_of (uri,arity) =
GrafiteAst.Coercion (HExtlib.dummy_floc, uri, false, arity)
let refinement_toolkit = {
baseuri
in
let moo_content =
- List.map (coercion_moo_statement_of arity) (uri::compounds)
+ List.map coercion_moo_statement_of ((uri,arity)::compounds)
in
let status = GrafiteTypes.add_moo_content moo_content status in
{status with GrafiteTypes.proof_status = GrafiteTypes.No_proof},
- compounds
-
-let eval_tactical ~disambiguate_tactic status tac =
- let apply_tactic = apply_tactic ~disambiguate_tactic in
- let module MatitaStatus =
- struct
- type input_status = GrafiteTypes.status * ProofEngineTypes.goal
-
- type output_status =
- GrafiteTypes.status * ProofEngineTypes.goal list * ProofEngineTypes.goal list
-
- type tactic = input_status -> output_status
-
- let id_tactic = apply_tactic ("",0,(GrafiteAst.IdTac HExtlib.dummy_floc))
- let mk_tactic tac = tac
- let apply_tactic tac = tac
- let goals (_, opened, closed) = opened, closed
- let set_goals (opened, closed) (status, _, _) = (status, opened, closed)
- let get_stack (status, _) = GrafiteTypes.get_stack status
-
- let get_status (status, goal) =
- match status.GrafiteTypes.proof_status with
- | GrafiteTypes.Incomplete_proof incomplete -> incomplete.GrafiteTypes.proof, goal
- | _ -> assert false
-
- let get_proof (status, _, _) =
- match status.GrafiteTypes.proof_status with
- | GrafiteTypes.Incomplete_proof incomplete -> incomplete.GrafiteTypes.proof
- | _ -> assert false
-
- let set_stack stack (status, opened, closed) =
- GrafiteTypes.set_stack stack status, opened, closed
-
- let inject (status, _) = (status, [], [])
- let focus goal (status, _, _) = (status, goal)
- end
- in
- let module MatitaTacticals = Tacticals.Make (MatitaStatus) in
- let rec tactical_of_ast l (text,prefix_len,tac) =
- let apply_tactic t = apply_tactic (text, prefix_len, t) in
- let tactical_of_ast l t = tactical_of_ast l (text,prefix_len,t) in
- match tac with
- | GrafiteAst.Tactic (loc, tactic) ->
- MatitaTacticals.tactic (MatitaStatus.mk_tactic (apply_tactic tactic))
- | GrafiteAst.Seq (loc, tacticals) -> (* tac1; tac2; ... *)
- assert (l > 0);
- MatitaTacticals.seq ~tactics:(List.map (tactical_of_ast (l+1)) tacticals)
- | GrafiteAst.Do (loc, n, tactical) ->
- MatitaTacticals.do_tactic ~n ~tactic:(tactical_of_ast (l+1) tactical)
- | GrafiteAst.Repeat (loc, tactical) ->
- MatitaTacticals.repeat_tactic ~tactic:(tactical_of_ast (l+1) tactical)
- | GrafiteAst.Then (loc, tactical, tacticals) -> (* tac; [ tac1 | ... ] *)
- assert (l > 0);
- MatitaTacticals.thens ~start:(tactical_of_ast (l+1) tactical)
- ~continuations:(List.map (tactical_of_ast (l+1)) tacticals)
- | GrafiteAst.First (loc, tacticals) ->
- MatitaTacticals.first
- ~tactics:(List.map (fun t -> "", tactical_of_ast (l+1) t) tacticals)
- | GrafiteAst.Try (loc, tactical) ->
- MatitaTacticals.try_tactic ~tactic:(tactical_of_ast (l+1) tactical)
- | GrafiteAst.Solve (loc, tacticals) ->
- MatitaTacticals.solve_tactics
- ~tactics:(List.map (fun t -> "", tactical_of_ast (l+1) t) tacticals)
- | GrafiteAst.Progress (loc, tactical) ->
- MatitaTacticals.progress_tactic ~tactic:(tactical_of_ast (l+1) tactical)
-
- | GrafiteAst.Skip _loc -> MatitaTacticals.skip
- | GrafiteAst.Dot _loc -> MatitaTacticals.dot
- | GrafiteAst.Semicolon _loc -> MatitaTacticals.semicolon
- | GrafiteAst.Branch _loc -> MatitaTacticals.branch
- | GrafiteAst.Shift _loc -> MatitaTacticals.shift
- | GrafiteAst.Pos (_loc, i) -> MatitaTacticals.pos i
- | GrafiteAst.Merge _loc -> MatitaTacticals.merge
- | GrafiteAst.Focus (_loc, goals) -> MatitaTacticals.focus goals
- | GrafiteAst.Unfocus _loc -> MatitaTacticals.unfocus
- | GrafiteAst.Wildcard _loc -> MatitaTacticals.wildcard
- in
- let status, _, _ = tactical_of_ast 0 tac (status, ~-1) in
+ List.map fst compounds
+
+module MatitaStatus =
+ struct
+ type input_status = GrafiteTypes.status * ProofEngineTypes.goal
+
+ type output_status =
+ GrafiteTypes.status * ProofEngineTypes.goal list * ProofEngineTypes.goal list
+
+ type tactic = input_status -> output_status
+
+ let mk_tactic tac = tac
+ let apply_tactic tac = tac
+ let goals (_, opened, closed) = opened, closed
+ let get_stack (status, _) = GrafiteTypes.get_stack status
+
+ let set_stack stack (status, opened, closed) =
+ GrafiteTypes.set_stack stack status, opened, closed
+
+ let inject (status, _) = (status, [], [])
+ let focus goal (status, _, _) = (status, goal)
+ end
+
+module MatitaTacticals = Continuationals.Make(MatitaStatus)
+
+let tactic_of_ast' tac =
+ MatitaTacticals.Tactical (MatitaTacticals.Tactic (MatitaStatus.mk_tactic tac))
+
+let punctuation_tactical_of_ast (text,prefix_len,punct) =
+ match punct with
+ | GrafiteAst.Dot _loc -> MatitaTacticals.Dot
+ | GrafiteAst.Semicolon _loc -> MatitaTacticals.Semicolon
+ | GrafiteAst.Branch _loc -> MatitaTacticals.Branch
+ | GrafiteAst.Shift _loc -> MatitaTacticals.Shift
+ | GrafiteAst.Pos (_loc, i) -> MatitaTacticals.Pos i
+ | GrafiteAst.Merge _loc -> MatitaTacticals.Merge
+ | GrafiteAst.Wildcard _loc -> MatitaTacticals.Wildcard
+
+let non_punctuation_tactical_of_ast (text,prefix_len,punct) =
+ match punct with
+ | GrafiteAst.Focus (_loc,goals) -> MatitaTacticals.Focus goals
+ | GrafiteAst.Unfocus _loc -> MatitaTacticals.Unfocus
+ | GrafiteAst.Skip _loc -> MatitaTacticals.Tactical MatitaTacticals.Skip
+
+let eval_tactical status tac =
+ let status, _, _ = MatitaTacticals.eval tac (status, ~-1) in
let status = (* is proof completed? *)
match status.GrafiteTypes.proof_status with
| GrafiteTypes.Incomplete_proof
in
let is_a_coercion, arity_coercion = is_a_coercion uri in
if is_a_coercion then
- Some (uri, coercion_moo_statement_of arity_coercion uri)
+ Some (uri, coercion_moo_statement_of (uri,arity_coercion))
else if is_a_wanted_coercion then
- Some (uri, coercion_moo_statement_of arity_wanted uri)
+ Some (uri, coercion_moo_statement_of (uri,arity_wanted))
else
None)
lemmas)
*)
status,[]
| GrafiteAst.Print (_,"proofterm") ->
- let _,_,p,_ = GrafiteTypes.get_current_proof status in
+ let _,_,p,_, _ = GrafiteTypes.get_current_proof status in
print_endline (AutoTactic.pp_proofterm p);
status,[]
| GrafiteAst.Print (_,_) -> status,[]
| GrafiteAst.Qed loc ->
- let uri, metasenv, bo, ty =
+ let uri, metasenv, bo, ty, attrs =
match status.GrafiteTypes.proof_status with
- | GrafiteTypes.Proof (Some uri, metasenv, body, ty) ->
- uri, metasenv, body, ty
- | GrafiteTypes.Proof (None, metasenv, body, ty) ->
+ | GrafiteTypes.Proof (Some uri, metasenv, body, ty, attrs) ->
+ uri, metasenv, body, ty, attrs
+ | GrafiteTypes.Proof (None, metasenv, body, ty, attrs) ->
raise (GrafiteTypes.Command_error
("Someone allows to start a theorem without giving the "^
"name/uri. This should be fixed!"))
(GrafiteTypes.Command_error
"Proof not completed! metasenv is not empty!");
let name = UriManager.name_of_uri uri in
- let obj = Cic.Constant (name,Some bo,ty,[],[]) in
+ let obj = Cic.Constant (name,Some bo,ty,[],attrs) in
let status, lemmas = add_obj uri obj status in
{status with
GrafiteTypes.proof_status = GrafiteTypes.No_proof},
+ (*CSC: I throw away the arities *)
uri::lemmas
| GrafiteAst.Relation (loc, id, a, aeq, refl, sym, trans) ->
Setoids.add_relation id a aeq refl sym trans;
let obj = CicRefine.pack_coercion_obj obj in
let metasenv = GrafiteTypes.get_proof_metasenv status in
match obj with
- | Cic.CurrentProof (_,metasenv',bo,ty,_,_) ->
+ | Cic.CurrentProof (_,metasenv',bo,ty,_, attrs) ->
let name = UriManager.name_of_uri uri in
if not(CicPp.check name ty) then
HLog.error ("Bad name: " ^ name);
("Theorem already proved: " ^ UriManager.string_of_uri x ^
"\nPlease use a variant."));
end;
- let initial_proof = (Some uri, metasenv', bo, ty) in
+ let initial_proof = (Some uri, metasenv', bo, ty, attrs) in
let initial_stack = Continuationals.Stack.of_metasenv metasenv' in
{ status with GrafiteTypes.proof_status =
GrafiteTypes.Incomplete_proof
} and eval_executable = {ee_go = fun ~disambiguate_tactic ~disambiguate_command
~disambiguate_macro opts status (text,prefix_len,ex) ->
match ex with
- | GrafiteAst.Tactical (_, tac, None) ->
- eval_tactical ~disambiguate_tactic status (text,prefix_len,tac),[]
- | GrafiteAst.Tactical (_, tac, Some punct) ->
+ | GrafiteAst.Tactic (_, Some tac, punct) ->
+ let tac = apply_tactic ~disambiguate_tactic (text,prefix_len,tac) in
+ let status = eval_tactical status (tactic_of_ast' tac) in
+ eval_tactical status
+ (punctuation_tactical_of_ast (text,prefix_len,punct)),[]
+ | GrafiteAst.Tactic (_, None, punct) ->
+ eval_tactical status
+ (punctuation_tactical_of_ast (text,prefix_len,punct)),[]
+ | GrafiteAst.NonPunctuationTactical (_, tac, punct) ->
let status =
- eval_tactical ~disambiguate_tactic status (text,prefix_len,tac) in
- eval_tactical ~disambiguate_tactic status (text,prefix_len,punct),[]
+ eval_tactical status
+ (non_punctuation_tactical_of_ast (text,prefix_len,tac))
+ in
+ eval_tactical status
+ (punctuation_tactical_of_ast (text,prefix_len,punct)),[]
| GrafiteAst.Command (_, cmd) ->
eval_command.ec_go ~disambiguate_command opts status (text,prefix_len,cmd)
| GrafiteAst.Macro (loc, macro) ->