clean_baseuri: bool
}
-type statement =
- (CicNotationPt.term, CicNotationPt.term, GrafiteAst.reduction, GrafiteAst.obj,
- string)
- GrafiteAst.statement
-
(** create a ProofEngineTypes.mk_fresh_name_type function which uses given
* names as long as they are available, then it fallbacks to name generation
* using FreshNamesGenerator module *)
| [x], _ -> x
| _ -> assert false
-let disambiguate_term status_ref term =
+ (** @param term not meaningful when context is given *)
+let disambiguate_term ?context status_ref goal term =
let status = !status_ref in
+ let context =
+ match context with
+ | Some c -> c
+ | None -> MatitaTypes.get_proof_context status goal
+ in
let (diff, metasenv, cic, _) =
singleton
(MatitaDisambiguator.disambiguate_term ~dbd:(MatitaDb.instance ())
~aliases:status.aliases ~universe:(Some status.multi_aliases)
- ~context:(MatitaMisc.get_proof_context status)
- ~metasenv:(MatitaMisc.get_proof_metasenv status) term)
+ ~context ~metasenv:(MatitaTypes.get_proof_metasenv status) term)
in
let status = MatitaTypes.set_metasenv metasenv status in
let status = MatitaSync.set_proof_aliases status diff in
| `Unfold None
| `Whd as kind -> kind
-let disambiguate_tactic status tactic =
+let disambiguate_tactic status goal tactic =
let status_ref = ref status in
let tactic =
match tactic with
| GrafiteAst.Absurd (loc, term) ->
- let cic = disambiguate_term status_ref term in
+ let cic = disambiguate_term status_ref goal term in
GrafiteAst.Absurd (loc, cic)
| GrafiteAst.Apply (loc, term) ->
- let cic = disambiguate_term status_ref term in
+ let cic = disambiguate_term status_ref goal term in
GrafiteAst.Apply (loc, cic)
| GrafiteAst.Assumption loc -> GrafiteAst.Assumption loc
| GrafiteAst.Auto (loc,depth,width,paramodulation,full) ->
| GrafiteAst.Clear (loc,id) -> GrafiteAst.Clear (loc,id)
| GrafiteAst.ClearBody (loc,id) -> GrafiteAst.ClearBody (loc,id)
| GrafiteAst.Compare (loc,term) ->
- let term = disambiguate_term status_ref term in
+ let term = disambiguate_term status_ref goal term in
GrafiteAst.Compare (loc,term)
| GrafiteAst.Constructor (loc,n) -> GrafiteAst.Constructor (loc,n)
| GrafiteAst.Contradiction loc -> GrafiteAst.Contradiction loc
| GrafiteAst.Cut (loc, ident, term) ->
- let cic = disambiguate_term status_ref term in
+ let cic = disambiguate_term status_ref goal term in
GrafiteAst.Cut (loc, ident, cic)
| GrafiteAst.DecideEquality loc -> GrafiteAst.DecideEquality loc
| GrafiteAst.Decompose (loc, types, what, names) ->
let disambiguate types = function
| GrafiteAst.Type _ -> assert false
| GrafiteAst.Ident id ->
- (match disambiguate_term status_ref (CicNotationPt.Ident (id, None)) with
+ (match disambiguate_term status_ref goal
+ (CicNotationPt.Ident (id, None))
+ with
| Cic.MutInd (uri, tyno, _) ->
(GrafiteAst.Type (uri, tyno) :: types)
- | _ -> raise Disambiguate.NoWellTypedInterpretation)
+ | _ -> raise (MatitaDisambiguator.DisambiguationError [[lazy "Decompose works only on inductive types"]]))
in
let types = List.fold_left disambiguate [] types in
GrafiteAst.Decompose (loc, types, what, names)
| GrafiteAst.Discriminate (loc,term) ->
- let term = disambiguate_term status_ref term in
+ let term = disambiguate_term status_ref goal term in
GrafiteAst.Discriminate(loc,term)
| GrafiteAst.Exact (loc, term) ->
- let cic = disambiguate_term status_ref term in
+ let cic = disambiguate_term status_ref goal term in
GrafiteAst.Exact (loc, cic)
| GrafiteAst.Elim (loc, what, Some using, depth, idents) ->
- let what = disambiguate_term status_ref what in
- let using = disambiguate_term status_ref using in
+ let what = disambiguate_term status_ref goal what in
+ let using = disambiguate_term status_ref goal using in
GrafiteAst.Elim (loc, what, Some using, depth, idents)
| GrafiteAst.Elim (loc, what, None, depth, idents) ->
- let what = disambiguate_term status_ref what in
+ let what = disambiguate_term status_ref goal what in
GrafiteAst.Elim (loc, what, None, depth, idents)
| GrafiteAst.ElimType (loc, what, Some using, depth, idents) ->
- let what = disambiguate_term status_ref what in
- let using = disambiguate_term status_ref using in
+ let what = disambiguate_term status_ref goal what in
+ let using = disambiguate_term status_ref goal using in
GrafiteAst.ElimType (loc, what, Some using, depth, idents)
| GrafiteAst.ElimType (loc, what, None, depth, idents) ->
- let what = disambiguate_term status_ref what in
+ let what = disambiguate_term status_ref goal what in
GrafiteAst.ElimType (loc, what, None, depth, idents)
| GrafiteAst.Exists loc -> GrafiteAst.Exists loc
| GrafiteAst.Fail loc -> GrafiteAst.Fail loc
| GrafiteAst.Goal (loc, g) -> GrafiteAst.Goal (loc, g)
| GrafiteAst.IdTac loc -> GrafiteAst.IdTac loc
| GrafiteAst.Injection (loc, term) ->
- let term = disambiguate_term status_ref term in
+ let term = disambiguate_term status_ref goal term in
GrafiteAst.Injection (loc,term)
| GrafiteAst.Intros (loc, num, names) -> GrafiteAst.Intros (loc, num, names)
| GrafiteAst.LApply (loc, depth, to_what, what, ident) ->
let f term to_what =
- let term = disambiguate_term status_ref term in
+ let term = disambiguate_term status_ref goal term in
term :: to_what
in
let to_what = List.fold_right f to_what [] in
- let what = disambiguate_term status_ref what in
+ let what = disambiguate_term status_ref goal what in
GrafiteAst.LApply (loc, depth, to_what, what, ident)
| GrafiteAst.Left loc -> GrafiteAst.Left loc
| GrafiteAst.LetIn (loc, term, name) ->
- let term = disambiguate_term status_ref term in
+ let term = disambiguate_term status_ref goal term in
GrafiteAst.LetIn (loc,term,name)
| GrafiteAst.Reduce (loc, red_kind, pattern) ->
let pattern = disambiguate_pattern status_ref pattern in
let with_what = disambiguate_lazy_term status_ref with_what in
GrafiteAst.Replace (loc, pattern, with_what)
| GrafiteAst.Rewrite (loc, dir, t, pattern) ->
- let term = disambiguate_term status_ref t in
+ let term = disambiguate_term status_ref goal t in
let pattern = disambiguate_pattern status_ref pattern in
GrafiteAst.Rewrite (loc, dir, term, pattern)
| GrafiteAst.Right loc -> GrafiteAst.Right loc
| GrafiteAst.Split loc -> GrafiteAst.Split loc
| GrafiteAst.Symmetry loc -> GrafiteAst.Symmetry loc
| GrafiteAst.Transitivity (loc, term) ->
- let cic = disambiguate_term status_ref term in
+ let cic = disambiguate_term status_ref goal term in
GrafiteAst.Transitivity (loc, cic)
in
status_ref, tactic
let reorder_metasenv start refine tactic goals current_goal always_opens_a_goal=
let module PEH = ProofEngineHelpers in
+(* let print_m name metasenv =
+ prerr_endline (">>>>> " ^ name);
+ prerr_endline (CicMetaSubst.ppmetasenv [] metasenv)
+ in *)
(* phase one calculates:
* new_goals_from_refine: goals added by refine
* head_goal: the first goal opened by ythe tactic
if always_opens_a_goal then
metas_for_tactic_head @ metas_for_refine_goals @
metas_for_tactic_goals
- else
+ else begin
+(* print_m "metas_for_refine_goals" metas_for_refine_goals;
+ print_m "metas_for_tactic_head" metas_for_tactic_head;
+ print_m "metas_for_tactic_goals" metas_for_tactic_goals; *)
metas_for_refine_goals @ metas_for_tactic_head @
metas_for_tactic_goals
+ end
in
let goals = List.map (fun (metano, _, _) -> metano) produced_metas in
produced_metas, goals
let after = extract after_l in
before, after
in
- (* DEBUG CODE
- let print_m name metasenv =
- prerr_endline (">>>>> " ^ name);
- prerr_endline (CicMetaSubst.ppmetasenv metasenv [])
- in
+(* |+ DEBUG CODE +|
print_m "BEGIN" start;
prerr_endline ("goal was: " ^ string_of_int current_goal);
prerr_endline ("and metas from refine are:");
print_m "metas_for_tactic_head" metas_for_tactic_head;
print_m "metas_for_refine_goals" metas_for_refine_goals;
print_m "metas_for_tactic_goals" metas_for_tactic_goals;
+ print_m "produced_metas" produced_metas;
print_m "after" after;
- FINE DEBUG CODE *)
+|+ FINE DEBUG CODE +| *)
before @ produced_metas @ after, goals
(* maybe we only need special cases for apply and goal *)
| GrafiteAst.IdTac _
| 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
(* tactics like apply *)
| _ -> true, false
-let apply_tactic tactic status =
- let starting_metasenv = MatitaMisc.get_proof_metasenv status in
- let status_ref, tactic = disambiguate_tactic status tactic in
- let metasenv_after_refinement = MatitaMisc.get_proof_metasenv !status_ref in
- let proof_status = MatitaMisc.get_proof_status !status_ref in
+let apply_tactic tactic (status, goal) =
+(* prerr_endline "apply_tactic"; *)
+(* prerr_endline (Continuationals.Stack.pp (MatitaTypes.get_stack status)); *)
+ let starting_metasenv = MatitaTypes.get_proof_metasenv status in
+ let before = List.map (fun g, _, _ -> g) starting_metasenv in
+(* prerr_endline "disambiguate"; *)
+ let status_ref, tactic = disambiguate_tactic status goal tactic in
+ let metasenv_after_refinement = MatitaTypes.get_proof_metasenv !status_ref in
+ let proof = MatitaTypes.get_current_proof !status_ref in
+ let proof_status = proof, goal in
let needs_reordering, always_opens_a_goal = classify_tactic tactic in
let tactic = tactic_of_ast tactic in
(* apply tactic will change the status pointed by status_ref ... *)
- let current_goal = let _, g = proof_status in g in
- let (proof, goals) = ProofEngineTypes.apply_tactic tactic proof_status in
- let proof, goals =
- if needs_reordering then
+(* 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
- let reordered_metasenv, goals =
- reorder_metasenv starting_metasenv metasenv_after_refinement
- metasenv_after_tactic goals current_goal always_opens_a_goal in
- (uri, reordered_metasenv, t, ty), goals
- else
- proof, goals
+(* 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
+ in
+ let incomplete_proof =
+ match !status_ref.proof_status with
+ | Incomplete_proof p -> p
+ | _ -> assert false
in
- let dummy = -1 in
- { !status_ref with
- proof_status = MatitaTypes.Incomplete_proof (proof,dummy) },
- goals
+ { !status_ref with proof_status =
+ Incomplete_proof { incomplete_proof with proof = proof } },
+ opened_goals, closed_goals
module MatitaStatus =
- struct
- type input_status = MatitaTypes.status
- type output_status = MatitaTypes.status * ProofEngineTypes.goal list
- type tactic = input_status -> output_status
-
- let focus (status,_) goal =
- let proof,_ = MatitaMisc.get_proof_status status in
- {status with proof_status = MatitaTypes.Incomplete_proof (proof,goal)}
+struct
+ type input_status = MatitaTypes.status * ProofEngineTypes.goal
- let goals (_,goals) = goals
+ type output_status =
+ MatitaTypes.status * ProofEngineTypes.goal list * ProofEngineTypes.goal list
- let set_goals (status,_) goals = status,goals
-
- let id_tac status =
- apply_tactic (GrafiteAst.IdTac DisambiguateTypes.dummy_floc) status
+ type tactic = input_status -> output_status
+ let id_tactic = apply_tactic (GrafiteAst.IdTac DisambiguateTypes.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, _) = MatitaTypes.get_stack status
+
+ let set_stack stack (status, opened, closed) =
+ MatitaTypes.set_stack stack status, opened, closed
- end
+ let inject (status, _) = (status, [], [])
+ let focus goal (status, _, _) = (status, goal)
+end
-module MatitaTacticals = Tacticals.Make(MatitaStatus)
+module MatitaTacticals = Tacticals.Make (MatitaStatus)
let eval_tactical status tac =
- let rec tactical_of_ast tac =
- match tac with
- | GrafiteAst.Tactic (loc, tactic) -> apply_tactic tactic
+ let rec tactical_of_ast l tac =
+ match tac with
+ | GrafiteAst.Tactic (loc, tactic) ->
+ MatitaTacticals.tactic (MatitaStatus.mk_tactic (apply_tactic tactic))
| GrafiteAst.Seq (loc, tacticals) -> (* tac1; tac2; ... *)
- MatitaTacticals.seq ~tactics:(List.map tactical_of_ast tacticals)
- | GrafiteAst.Do (loc, num, tactical) ->
- MatitaTacticals.do_tactic ~n:num ~tactic:(tactical_of_ast tactical)
+ 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 tactical)
+ MatitaTacticals.repeat_tactic ~tactic:(tactical_of_ast (l+1) tactical)
| GrafiteAst.Then (loc, tactical, tacticals) -> (* tac; [ tac1 | ... ] *)
- MatitaTacticals.thens ~start:(tactical_of_ast tactical)
- ~continuations:(List.map tactical_of_ast tacticals)
+ 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 t) tacticals)
+ ~tactics:(List.map (fun t -> "", tactical_of_ast (l+1) t) tacticals)
| GrafiteAst.Try (loc, tactical) ->
- MatitaTacticals.try_tactic ~tactic:(tactical_of_ast 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 t) tacticals)
- in
- let status,goals = tactical_of_ast tac status in
- let proof,_ = MatitaMisc.get_proof_status status in
- let new_status =
- match goals with
- | [] ->
- let (_,metasenv,_,_) = proof in
- (match metasenv with
- | [] -> Proof proof
- | (ng,_,_)::_ -> Incomplete_proof (proof,ng))
- | ng::_ -> Incomplete_proof (proof, ng)
+ ~tactics:(List.map (fun t -> "", tactical_of_ast (l+1) t) tacticals)
+
+ | 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
+ in
+ let status, _, _ = tactical_of_ast 0 tac (status, ~-1) in
+ let status = (* is proof completed? *)
+ match status.proof_status with
+ | Incomplete_proof { stack = stack; proof = proof }
+ when Continuationals.Stack.is_empty stack ->
+ { status with proof_status = Proof proof }
+ | _ -> status
in
- { status with proof_status = new_status }
+ status
let eval_coercion status coercion =
let coer_uri,coer_ty =
let new_coercions =
CoercGraph.close_coercion_graph src_uri tgt_uri coer_uri in
let status =
- List.fold_left (fun s (uri,o,_) -> MatitaSync.add_obj uri o status)
+ List.fold_left (fun s (uri,o,_) ->
+ let status = MatitaSync.add_obj uri o status in
+ {status with coercions = uri :: status.coercions})
status new_coercions in
+ let status = {status with coercions = coer_uri :: status.coercions} in
let statement_of name =
GrafiteAst.Coercion (DisambiguateTypes.dummy_floc,
(CicNotationPt.Ident (name, None)))
match obj with
GrafiteAst.Inductive (_,(name,_,_,_)::_)
| GrafiteAst.Record (_,name,_,_) ->
- Some (UriManager.uri_of_string (MatitaMisc.qualify status name ^ ".ind"))
+ Some (UriManager.uri_of_string (MatitaTypes.qualify status name ^ ".ind"))
| GrafiteAst.Inductive _ -> assert false
| GrafiteAst.Theorem _ -> None in
let (diff, metasenv, cic, _) =
status,cmd
| GrafiteAst.Coercion (loc, term) ->
let status_ref = ref status in
- let term = disambiguate_term status_ref term in
+ let term = disambiguate_term ~context:[] status_ref ~-1 term in
!status_ref, GrafiteAst.Coercion (loc,term)
| GrafiteAst.Obj (loc,obj) ->
let status,obj = disambiguate_obj status obj in
add_moo_content [cmd] status
| GrafiteAst.Include (loc, path) ->
let absolute_path = make_absolute opts.include_paths path in
- let moopath = MatitaMisc.obj_file_of_script absolute_path in
+ let moopath = MatitacleanLib.obj_file_of_script absolute_path in
let status = ref status in
if not (Sys.file_exists moopath) then
raise (IncludedFileNotCompiled moopath);
command_error
("Someone allows to start a thm without giving the "^
"name/uri. This should be fixed!")
- | _-> command_error "You can't qed an uncomplete theorem"
+ | _-> command_error "You can't Qed an incomplete theorem"
in
let suri = UriManager.string_of_uri uri in
if metasenv <> [] then
(match types with (name,_,_,_)::_ -> name | _ -> assert false)
| _ -> assert false in
let uri =
- UriManager.uri_of_string (MatitaMisc.qualify status name ^ ext)
+ UriManager.uri_of_string (MatitaTypes.qualify status name ^ ext)
in
- let metasenv = MatitaMisc.get_proof_metasenv status in
+ let metasenv = MatitaTypes.get_proof_metasenv status in
match obj with
| Cic.CurrentProof (_,metasenv',bo,ty,_,_) ->
let name = UriManager.name_of_uri uri in
match metasenv' with (goalno,_,_)::_ -> goalno | _ -> assert false
in
let initial_proof = (Some uri, metasenv, bo, ty) in
- { status with proof_status = Incomplete_proof (initial_proof,goalno)}
+ let initial_stack = Continuationals.Stack.of_metasenv metasenv in
+ { status with proof_status =
+ Incomplete_proof { proof = initial_proof; stack = initial_stack } }
| _ ->
if metasenv <> [] then
command_error (
let eval_executable opts status ex =
match ex with
- | GrafiteAst.Tactical (_, tac) -> eval_tactical status tac
+ | GrafiteAst.Tactical (_, tac, None) -> eval_tactical status tac
+ | GrafiteAst.Tactical (_, tac, Some punct) ->
+ let status = eval_tactical status tac in
+ eval_tactical status punct
| GrafiteAst.Command (_, cmd) -> eval_command opts status cmd
| GrafiteAst.Macro (_, mac) ->
command_error (sprintf "The macro %s can't be in a script"
let eval_string ?do_heavy_checks ?include_paths ?clean_baseuri status str =
eval_from_stream
?do_heavy_checks ?include_paths ?clean_baseuri status
- (Ulexing.from_utf8_string str) (fun _ _ ->())
+ (Ulexing.from_utf8_string str) (fun _ _ -> ())
let default_options () =
(*
proof_status = No_proof;
options = default_options ();
objects = [];
+ coercions = [];
notation_ids = [];
}
projects / helm.git / blobdiff