Goal:
  
  elt : Type
  eq_elt : elt -> elt -> Prop
  m : t elt
  m' : t elt
  H : forall x y : key, E.eq x y -> find x m = find y m
  H0 : forall x y : key, E.eq x y -> find x m' = find y m'
  H1 : (forall k : key,
        (exists (e : elt) (y : key × elt),
           (E.eq k y.1 /\ e = y.2) /\ List.In y (elements m)) ->
        match find k m with
        | Some x =>
            match find k m' with
            | Some y => eq_elt x y
            | None => False
            end
        | None => match find k m' with
                  | Some _ => False
                  | None => True
                  end
        end) /\
       (forall k : key,
        (exists (e : elt) (y : key × elt),
           (E.eq k y.1 /\ e = y.2) /\ List.In y (elements m')) ->
        match find k m with
        | Some x =>
            match find k m' with
            | Some y => eq_elt x y
            | None => False
            end
        | None => match find k m' with
                  | Some _ => False
                  | None => True
                  end
        end)
  x : key × elt
  H2 : List.In x (elements m)
  ============================
   (let
    '(k, _) := x in
     match find k m with
     | Some x =>
         match find k m' with
         | Some y0 => eq_elt x y0
         | None => False
         end
     | None => match find k m' with
               | Some _ => False
               | None => True
               end
     end)


DEBUG:Going to execute:
intros ||
             destruct_head'_and ||
               split_iff || destruct_head'_prod || destruct_head'_ex || subst
Level 1: Backtrace:

Not an inductive definition.
Level 0: Backtrace:

Not an inductive definition.