- Another bug in get_sort_family_of (sort-polymorphism of constants and

  inductive types was not taken into account).
- Virtually extended tauto to 
  - support arbitrary-length disjunctions and conjunctions,
  - support arbitrary complex forms of disjunctions and
    conjunctions when in the contravariant of an implicative hypothesis,
  - stick with the purely propositional fragment and not apply reflexivity.
  This is virtual in the sense that it is not activated since it breaks 
  compatibility with the existing tauto.
- Modified the notion of conjunction and unit type used in hipattern in a 
  way that is closer to the intuitive meaning (forbid dependencies 
  between parameters in conjunction; forbid indices in unit types).
- Investigated how far "iff" could be turned into a direct inductive
  definition; modified tauto.ml4 so that it works with the current and
  the alternative definition.
- Fixed a bug in the error message from lookup_eliminator.
- Other minor changes.



git-svn-id: svn+ssh://scm.gforge.inria.fr/svn/coq/trunk@11721 85f007b7-540e-0410-9357-904b9bb8a0f7

1 files changed, 8 insertions, 7 deletions

diff --git a/tactics/hipattern.mli b/tactics/hipattern.mli
index a97891c14..b2e25b42d 100644
--- a/tactics/hipattern.mli
+++ b/tactics/hipattern.mli
@@ -52,19 +52,20 @@ type testing_function = constr -> bool
 val match_with_non_recursive_type : (constr * constr list) matching_function
 val is_non_recursive_type         : testing_function 
 
-val match_with_disjunction : (constr * constr list) matching_function
-val is_disjunction         : testing_function 
+val match_with_disjunction : ?strict:bool -> (constr * constr list) matching_function
+val is_disjunction         : ?strict:bool -> testing_function 
 
-val match_with_conjunction : (constr * constr list) matching_function
-val match_with_conjunction_size : (constr * constr list * int) matching_function
-val is_conjunction         : testing_function 
+val match_with_conjunction : ?strict:bool -> (constr * constr list) matching_function
+val is_conjunction         : ?strict:bool -> testing_function 
 
 val match_with_empty_type  : constr matching_function
 val is_empty_type          : testing_function 
 
-val match_with_unit_type   : constr matching_function
+(* type with only one constructor and no arguments, possibly with indices *)
+val match_with_unit_or_eq_type : constr matching_function
+val is_unit_or_eq_type     : testing_function 
 
-(* type with only one constructor and no arguments *)
+(* type with only one constructor and no arguments, no indices *)
 val is_unit_type           : testing_function 
 
 val match_with_equation    : (constr * constr list) matching_function