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
  
 
   type output_status
 
   type tactic
-
-  val id_tactic : tactic
   val mk_tactic : (input_status -> output_status) -> tactic
   val apply_tactic : tactic -> input_status -> output_status
 
-  val get_status: input_status -> ProofEngineTypes.status
-  val get_proof: output_status -> ProofEngineTypes.proof
   val goals : output_status -> goal list * goal list (** opened, closed goals *)
-  val set_goals: goal list * goal list -> output_status -> output_status
   val get_stack : input_status -> Stack.t
   val set_stack : Stack.t -> output_status -> output_status
 
 
   type output_status
 
   type tactic
-
-  val id_tactic : tactic
   val mk_tactic : (input_status -> output_status) -> tactic
   val apply_tactic : tactic -> input_status -> output_status
 
-  val get_status: input_status -> ProofEngineTypes.status
-  val get_proof: output_status -> ProofEngineTypes.proof
   val goals : output_status -> goal list * goal list (** opened, closed goals *)
-  val set_goals: goal list * goal list -> output_status -> output_status
   val get_stack : input_status -> Stack.t
   val set_stack : Stack.t -> output_status -> output_status
 
 
 
   type tactic = PET.tactic
 
-  let id_tactic = id_tac
-
   (* f is an eval function of a machine;
      the machine is applied to a fresh stack and the final stack is read
      back to obtain the result of the tactic *)
     let opened_goals, closed_goals = goals_diff ~before ~after ~opened in
     (proof', opened_goals, closed_goals), stack
 
-  let get_status (status, _) = status
-  let get_proof ((proof, _, _), _) = proof
-
   let goals ((_, opened, closed), _) = opened, closed
-  let set_goals (opened, closed) ((proof, _, _), stack) =
-    (proof, opened, closed), stack
 
   (* Done only at the beginning of the eval of the machine *)
   let get_stack = snd