-!A:Prop.!B:Prop.!C:Prop.(and (or A C) (and (or A B) (or B C))) -> True
+!A:Prop.!B:Prop.!C:Prop.(and (sumbool A False) (and (or True B) (or B False))) -> True
!A:Prop.!B:Prop.!C:Prop.(and (sumbool A C) (and (or A B) !D:Prop.(or B D))) -> True
!A:Prop.!B:Prop.!C:Prop.(and (and A C) (and (and A B) (and B C))) -> True
+
+(and True True) -> True
+(and True False) -> True
let replaceb =
GButton.button ~label:"Replace"
~packing:(hbox7#pack ~expand:false ~fill:false ~padding:5) () in
+ let injectionb =
+ GButton.button ~label:"Injection"
+ ~packing:(hbox7#pack ~expand:false ~fill:false ~padding:5) () in
+ let discriminateb =
+ GButton.button ~label:"Discriminate"
+ ~packing:(hbox7#pack ~expand:false ~fill:false ~padding:5) () in
(* Zack: spostare in una toolbar
let generalizeb =
GButton.button ~label:"Generalize"
ignore(introsb#connect#clicked InvokeTactics'.intros) ;
ignore(decomposeb#connect#clicked InvokeTactics'.decompose) ;
ignore(searchpatternb#connect#clicked searchPattern) ;
+ ignore(injectionb#connect#clicked InvokeTactics'.injection) ;
+ ignore(discriminateb#connect#clicked InvokeTactics'.discriminate) ;
(* Zack: spostare in una toolbar
ignore(whdb#connect#clicked whd) ;
ignore(reduceb#connect#clicked reduce) ;
let left = call_tactic ProofEngine.left
let right = call_tactic ProofEngine.right
let assumption = call_tactic ProofEngine.assumption
+ let injection = call_tactic_with_input ProofEngine.injection
+ let discriminate = call_tactic_with_input ProofEngine.discriminate
let generalize =
call_tactic_with_goal_inputs
(ProofEngine.generalize ~mk_fresh_name_callback:C.mk_fresh_name_callback)
val absurd : unit -> unit
val contradiction : unit -> unit
val decompose : unit -> unit
+ val injection : unit -> unit
+ val discriminate : unit -> unit
val whd_in_scratch : unit -> unit
val reduce_in_scratch : unit -> unit
val simpl_in_scratch : unit -> unit
let decompose ~uris_choice_callback term =
apply_tactic (EliminationTactics.decompose_tac ~uris_choice_callback term)
-(*
-let decide_equality () = apply_tactic VariousTactics.decide_equality_tac
-let compare term1 term2 = apply_tactic (VariousTactics.compare_tac ~term1 ~term2)
-*)
+let injection term = apply_tactic (DiscriminateTactics.injection_tac ~term)
+let discriminate term = apply_tactic (DiscriminateTactics.discriminate_tac ~term)
+let decide_equality () = apply_tactic DiscriminateTactics.decide_equality_tac
+let compare term = apply_tactic (DiscriminateTactics.compare_tac ~term)
(*
let prova_tatticali () = apply_tactic Tacticals.prova_tac
(UriManager.uri * int * (UriManager.uri * Cic.term) list) list) ->
Cic.term -> unit
-(*
+val injection : Cic.term -> unit
+val discriminate : Cic.term -> unit
val decide_equality : unit -> unit
-val compare : Cic.term -> Cic.term -> unit
-*)
+val compare : Cic.term -> unit
+
(*
val prova_tatticali : unit -> unit