Goal:
  
  A : Type
  B : Type
  P : A → B → Prop
  P' : ∀ (a : A) (b : B), P a b → Prop
  t : A
  t' : B
  x : A
  y : B
  l : list A
  l' : list B
  r : P x y
  rs : Forall2 P l l'
  H : P' x y r
  H' : Forall2_dep P' rs
  IHH' : ∀ (n : nat) (H1 : nth_error l n = Some t) 
           (H2 : nth_error l' n = Some t'),
           P' t t' (Forall2_nth_error n t t' rs H1 H2)
  n : nat
  ============================
   (∀ (H1 : nth_error l n = Some t) (H2 : nth_error l' n = Some t'),
      P' t t'
        (Forall2_ind
           (λ (l : list A) (l' : list B),
              ∀ n : nat,
                nth_error l n = Some t → nth_error l' n = Some t' → P t t')
           (λ n : nat,
              match
                n as n0
                return
                  (nth_error [] n0 = Some t
                   → nth_error [] n0 = Some t' → P t t')
              with
              | 0 | _ =>
                  λ (_ : None = Some t) (H0 : None = Some t'),
                    False_ind (P t t')
                      (eq_ind None
                         (λ e : option B,
                            match e with
                            | Some _ => False
                            | None => True
                            end) I (Some t') H0)
              end)
           (λ (x : A) (y : B) (l : list A) (l' : list B) 
              (H : P x y) (_ : Forall2 P l l') (IHHall : 
                                                ∀ n : nat,
                                                 nth_error l n = Some t
                                                 → 
                                                 nth_error l' n = Some t'
                                                 → 
                                                 P t t') 
              (n : nat),
              match
                n as n0
                return
                  (nth_error (x :: l) n0 = Some t
                   → nth_error (y :: l') n0 = Some t' → P t t')
              with
              | 0 =>
                  λ (H0 : Some x = Some t) (H3 : Some y = Some t'),
                    rew [λ X : Prop, X]
                        eq_trans
                          (f_equal (λ f : B → Prop, f y)
                             (eq_trans eq_refl
                                (f_equal P
                                   (f_equal
                                      (λ t0 : option A,
                                         match t0 with
                                         | Some x0 => x0
                                         | None => x
                                         end) H0))))
                          (f_equal (P t)
                             (f_equal
                                (λ t0 : option B,
                                   match t0 with
                                   | Some x0 => x0
                                   | None => y
                                   end) H3)) in H
              | S n0 =>
                  λ (H0 : nth_error l n0 = Some t) 
                    (H3 : nth_error l' n0 = Some t'), 
                    IHHall n0 H0 H3
              end) rs n H1 H2))


DEBUG:Going to execute:
congruence
Level 0: Backtrace:

Tactic failure: congruence failed.
Level 0: Backtrace:

Tactic failure: congruence failed.