Goal:
  
  A : Type
  B : Type
  R : A → B → Type
  R' : ∀ (a : A) (b : B), R a b → Type
  ============================
   (apply_noConfusion [] []
      (Logic.True_rect_dep
         (λ H : True,
            ∀ e : eq_rect []
                    (λ xs : list A, sigma (λ ys : list B, All2 R xs ys))
                    {| pr1 := []; pr2 := All2_nil |} []
                    match H with
                    | I => eq_refl
                    end = {| pr1 := []; pr2 := All2_nil |},
              eq_rect
                {| pr1 := []; pr2 := {| pr1 := []; pr2 := All2_nil |} |}
                (λ index : sigma
                             (λ xs : list A,
                                sigma (λ ys : list B, All2 R xs ys)),
                   All2_dep R' (pr2 (pr2 index))) All2_dep_nil
                {| pr1 := []; pr2 := {| pr1 := []; pr2 := All2_nil |} |}
                (DepElim.pack_sigma_eq match H with
                                       | I => eq_refl
                                       end e) = All2_dep_nil
              → apply_noConfusion [] []
                  (Logic.True_rect_dep
                     (λ H0 : True,
                        eq_rect []
                          (λ xs : list A, sigma (λ ys : list B, All2 R xs ys))
                          {| pr1 := []; pr2 := All2_nil |} []
                          match H0 with
                          | I => eq_refl
                          end = {| pr1 := []; pr2 := All2_nil |} → Prop)
                     (DepElim.eq_simplification_sigma1_dep [] [] All2_nil
                        All2_nil
                        (apply_noConfusion [] []
                           (Logic.True_rect_dep
                              (λ H0 : True,
                                 eq_rect [] (λ ys : list B, All2 R [] ys)
                                   All2_nil []
                                   match H0 with
                                   | I => eq_refl
                                   end = All2_nil → Prop)
                              (apply_noConfusion All2_nil All2_nil
                                 (λ _ : True, True)))))) eq_refl eq_refl
                → All2_dep_nil = All2_dep_nil)
         (DepElim.eq_simplification_sigma1_dep_dep [] [] All2_nil All2_nil
            (apply_noConfusion [] []
               (Logic.True_rect_dep
                  (λ H : True,
                     ∀ e : eq_rect [] (λ ys : list B, All2 R [] ys) All2_nil
                             [] match H with
                                | I => eq_refl
                                end = All2_nil,
                       eq_rect
                         {|
                           pr1 := []; pr2 := {| pr1 := []; pr2 := All2_nil |}
                         |}
                         (λ index : sigma
                                      (λ xs : list A,
                                         sigma (λ ys : list B, All2 R xs ys)),
                            All2_dep R' (pr2 (pr2 index))) All2_dep_nil
                         {|
                           pr1 := []; pr2 := {| pr1 := []; pr2 := All2_nil |}
                         |}
                         match
                           DepElim.pack_sigma_eq
                             match H with
                             | I => eq_refl
                             end e in (_ = p)
                           return
                             ({|
                                pr1 := [];
                                pr2 := {| pr1 := []; pr2 := All2_nil |}
                              |} = {| pr1 := []; pr2 := p |})
                         with
                         | eq_refl => eq_refl
                         end = All2_dep_nil
                       → apply_noConfusion [] []
                           (Logic.True_rect_dep
                              (λ H0 : True,
                                 eq_rect []
                                   (λ xs : list A,
                                      sigma (λ ys : list B, All2 R xs ys))
                                   {| pr1 := []; pr2 := All2_nil |} []
                                   match H0 with
                                   | I => eq_refl
                                   end = {| pr1 := []; pr2 := All2_nil |}
                                 → Prop)
                              (DepElim.eq_simplification_sigma1_dep [] []
                                 All2_nil All2_nil
                                 (apply_noConfusion [] []
                                    (Logic.True_rect_dep
                                       (λ H0 : True,
                                          eq_rect []
                                            (λ ys : list B, All2 R [] ys)
                                            All2_nil []
                                            match H0 with
                                            | I => eq_refl
                                            end = All2_nil → Prop)
                                       (apply_noConfusion All2_nil All2_nil
                                          (λ _ : True, True)))))) eq_refl
                           eq_refl → All2_dep_nil = All2_dep_nil)
                  (apply_noConfusion All2_nil All2_nil
                     (Logic.True_rect_dep
                        (λ H : True,
                           eq_rect
                             {|
                               pr1 := [];
                               pr2 := {| pr1 := []; pr2 := All2_nil |}
                             |}
                             (λ index : sigma
                                          (λ xs : list A,
                                             sigma
                                               (λ ys : list B, All2 R xs ys)),
                                All2_dep R' (pr2 (pr2 index))) All2_dep_nil
                             {|
                               pr1 := [];
                               pr2 := {| pr1 := []; pr2 := All2_nil |}
                             |}
                             match
                               match
                                 apply_noConfusion [] []
                                   (Logic.True_rect_dep
                                      (λ H0 : True,
                                         ∀ e : [] = [],
                                           eq_rect 
                                             {| pr1 := []; pr2 := [] |}
                                             (λ index : 
                                                 sigma 
                                                 (λ _ : list A, list B),
                                                All2 R 
                                                 (pr1 index) 
                                                 (pr2 index)) All2_nil
                                             {| pr1 := []; pr2 := [] |}
                                             (DepElim.pack_sigma_eq_nondep
                                                match H0 with
                                                | I => eq_refl
                                                end e) = All2_nil
                                           → apply_noConfusion [] []
                                               (λ _ : True,
                                                 apply_noConfusion [] []
                                                 (λ _ : True, True)) eq_refl
                                               eq_refl → 
                                             All2_nil = All2_nil)
                                      (apply_noConfusion [] []
                                         (Logic.True_rect_dep
                                            (λ H0 : True,
                                               eq_rect
                                                 {| pr1 := []; pr2 := [] |}
                                                 (λ index : 
                                                 sigma 
                                                 (λ _ : list A, list B),
                                                 All2 R 
                                                 (pr1 index) 
                                                 (pr2 index)) All2_nil
                                                 {| pr1 := []; pr2 := [] |}
                                                 match
                                                 match H0 with
                                                 | I => eq_refl
                                                 end in 
                                                 (_ = p)
                                                 return
                                                 ({| pr1 := []; pr2 := [] |} =
                                                 {| pr1 := []; pr2 := p |})
                                                 with
                                                 | eq_refl => eq_refl
                                                 end = All2_nil
                                               → apply_noConfusion [] []
                                                 (λ _ : True,
                                                 apply_noConfusion [] []
                                                 (λ _ : True, True)) eq_refl
                                                 eq_refl
                                                 → 
                                                 All2_nil = All2_nil)
                                            (λ H0 : All2_nil = All2_nil,
                                               DepElim.solution_left All2_nil
                                                 (λ H1 : 
                                                 apply_noConfusion [] []
                                                 (λ _ : True,
                                                 apply_noConfusion [] []
                                                 (λ _ : True, True)) eq_refl
                                                 eq_refl,
                                                 match H1 with
                                                 | I => eq_refl
                                                 end) All2_nil H0)))) eq_refl
                                   eq_refl eq_refl H in 
                                 (_ = p)
                                 return
                                   ({| pr1 := []; pr2 := All2_nil |} =
                                    {| pr1 := []; pr2 := p |})
                               with
                               | eq_refl => eq_refl
                               end in (_ = p)
                               return
                                 ({|
                                    pr1 := [];
                                    pr2 := {| pr1 := []; pr2 := All2_nil |}
                                  |} = {| pr1 := []; pr2 := p |})
                             with
                             | eq_refl => eq_refl
                             end = All2_dep_nil
                           → apply_noConfusion [] []
                               (Logic.True_rect_dep
                                  (λ H0 : True,
                                     eq_rect []
                                       (λ xs : list A,
                                          sigma (λ ys : list B, All2 R xs ys))
                                       {| pr1 := []; pr2 := All2_nil |} []
                                       match H0 with
                                       | I => eq_refl
                                       end = {| pr1 := []; pr2 := All2_nil |}
                                     → Prop)
                                  (DepElim.eq_simplification_sigma1_dep [] []
                                     All2_nil All2_nil
                                     (apply_noConfusion [] []
                                        (Logic.True_rect_dep
                                           (λ H0 : True,
                                              eq_rect []
                                                (λ ys : list B, All2 R [] ys)
                                                All2_nil []
                                                match H0 with
                                                | I => eq_refl
                                                end = All2_nil → Prop)
                                           (apply_noConfusion All2_nil
                                              All2_nil 
                                              (λ _ : True, True)))))) eq_refl
                               eq_refl → All2_dep_nil = All2_dep_nil)
                        (λ H : All2_dep_nil = All2_dep_nil,
                           DepElim.solution_left All2_dep_nil
                             (λ H0 : apply_noConfusion [] []
                                       (Logic.True_rect_dep
                                          (λ H0 : True,
                                             eq_rect []
                                               (λ xs : list A,
                                                 sigma
                                                 (λ ys : list B, All2 R xs ys))
                                               {|
                                                 pr1 := []; pr2 := All2_nil
                                               |} []
                                               match H0 with
                                               | I => eq_refl
                                               end =
                                             {| pr1 := []; pr2 := All2_nil |}
                                             → Prop)
                                          (DepElim.eq_simplification_sigma1_dep
                                             [] [] All2_nil All2_nil
                                             (apply_noConfusion [] []
                                                (Logic.True_rect_dep
                                                 (λ H0 : True,
                                                 eq_rect []
                                                 (λ ys : list B, All2 R [] ys)
                                                 All2_nil []
                                                 match H0 with
                                                 | I => eq_refl
                                                 end = All2_nil → Prop)
                                                 (apply_noConfusion All2_nil
                                                 All2_nil 
                                                 (λ _ : True, True))))))
                                       eq_refl eq_refl,
                                match H0 with
                                | I => eq_refl
                                end) All2_dep_nil H))))))) eq_refl eq_refl
      eq_refl I = eq_refl)


DEBUG:Going to execute:
let y' := eval hnf in y in
           change_no_check (x' = y')
DEBUG LTAC Evaluated term: (apply_noConfusion [] []
                              (Logic.True_rect_dep
                                 (λ H : True,
                                    ∀ e : eq_rect []
                                            (λ xs : list A,
                                               sigma
                                                 (λ ys : list B, All2 R xs ys))
                                            {| pr1 := []; pr2 := All2_nil |}
                                            []
                                            match H with
                                            | I => eq_refl
                                            end =
                                          {| pr1 := []; pr2 := All2_nil |},
                                      eq_rect
                                        {|
                                          pr1 := [];
                                          pr2 :=
                                            {| pr1 := []; pr2 := All2_nil |}
                                        |}
                                        (λ index : 
                                            sigma
                                              (λ xs : list A,
                                                 sigma
                                                 (λ ys : list B, All2 R xs ys)),
                                           All2_dep R' (pr2 (pr2 index)))
                                        All2_dep_nil
                                        {|
                                          pr1 := [];
                                          pr2 :=
                                            {| pr1 := []; pr2 := All2_nil |}
                                        |}
                                        (DepElim.pack_sigma_eq
                                           match H with
                                           | I => eq_refl
                                           end e) = All2_dep_nil
                                      → apply_noConfusion [] []
                                          (Logic.True_rect_dep
                                             (λ H0 : True,
                                                eq_rect []
                                                 (λ xs : list A,
                                                 sigma
                                                 (λ ys : list B, All2 R xs ys))
                                                 {|
                                                 pr1 := []; pr2 := All2_nil
                                                 |} []
                                                 match H0 with
                                                 | I => eq_refl
                                                 end =
                                                {|
                                                 pr1 := []; pr2 := All2_nil
                                                |} → Prop)
                                             (DepElim.eq_simplification_sigma1_dep
                                                [] [] All2_nil All2_nil
                                                (apply_noConfusion [] []
                                                 (Logic.True_rect_dep
                                                 (λ H0 : True,
                                                 eq_rect []
                                                 (λ ys : list B, All2 R [] ys)
                                                 All2_nil []
                                                 match H0 with
                                                 | I => eq_refl
                                                 end = All2_nil → Prop)
                                                 (apply_noConfusion All2_nil
                                                 All2_nil 
                                                 (λ _ : True, True))))))
                                          eq_refl eq_refl
                                        → All2_dep_nil = All2_dep_nil)
                                 (DepElim.eq_simplification_sigma1_dep_dep []
                                    [] All2_nil All2_nil
                                    (apply_noConfusion [] []
                                       (Logic.True_rect_dep
                                          (λ H : True,
                                             ∀ e : 
                                                eq_rect []
                                                 (λ ys : list B, All2 R [] ys)
                                                 All2_nil []
                                                 match H with
                                                 | I => eq_refl
                                                 end = All2_nil,
                                               eq_rect
                                                 {|
                                                 pr1 := [];
                                                 pr2 :=
                                                 {|
                                                 pr1 := []; pr2 := All2_nil
                                                 |}
                                                 |}
                                                 (λ index : 
                                                 sigma
                                                 (λ xs : list A,
                                                 sigma
                                                 (λ ys : list B, All2 R xs ys)),
                                                 All2_dep R'
                                                 (pr2 (pr2 index)))
                                                 All2_dep_nil
                                                 {|
                                                 pr1 := [];
                                                 pr2 :=
                                                 {|
                                                 pr1 := []; pr2 := All2_nil
                                                 |}
                                                 |}
                                                 match
                                                 DepElim.pack_sigma_eq
                                                 match H with
                                                 | I => eq_refl
                                                 end e in 
                                                 (_ = p)
                                                 return
                                                 ({|
                                                 pr1 := [];
                                                 pr2 :=
                                                 {|
                                                 pr1 := []; pr2 := All2_nil
                                                 |}
                                                 |} =
                                                 {| pr1 := []; pr2 := p |})
                                                 with
                                                 | eq_refl => eq_refl
                                                 end = All2_dep_nil
                                               → apply_noConfusion [] []
                                                 (Logic.True_rect_dep
                                                 (λ H0 : True,
                                                 eq_rect []
                                                 (λ xs : list A,
                                                 sigma
                                                 (λ ys : list B, All2 R xs ys))
                                                 {|
                                                 pr1 := []; pr2 := All2_nil
                                                 |} []
                                                 match H0 with
                                                 | I => eq_refl
                                                 end =
                                                 {|
                                                 pr1 := []; pr2 := All2_nil
                                                 |} → Prop)
                                                 (DepElim.eq_simplification_sigma1_dep
                                                 [] [] All2_nil All2_nil
                                                 (apply_noConfusion [] []
                                                 (Logic.True_rect_dep
                                                 (λ H0 : True,
                                                 eq_rect []
                                                 (λ ys : list B, All2 R [] ys)
                                                 All2_nil []
                                                 match H0 with
                                                 | I => eq_refl
                                                 end = All2_nil → Prop)
                                                 (apply_noConfusion All2_nil
                                                 All2_nil 
                                                 (λ _ : True, True))))))
                                                 eq_refl eq_refl
                                                 → 
                                                 All2_dep_nil = All2_dep_nil)
                                          (apply_noConfusion All2_nil
                                             All2_nil
                                             (Logic.True_rect_dep
                                                (λ H : True,
                                                 eq_rect
                                                 {|
                                                 pr1 := [];
                                                 pr2 :=
                                                 {|
                                                 pr1 := []; pr2 := All2_nil
                                                 |}
                                                 |}
                                                 (λ index : 
                                                 sigma
                                                 (λ xs : list A,
                                                 sigma
                                                 (λ ys : list B, All2 R xs ys)),
                                                 All2_dep R'
                                                 (pr2 (pr2 index)))
                                                 All2_dep_nil
                                                 {|
                                                 pr1 := [];
                                                 pr2 :=
                                                 {|
                                                 pr1 := []; pr2 := All2_nil
                                                 |}
                                                 |}
                                                 match
                                                 match
                                                 apply_noConfusion [] []
                                                 (Logic.True_rect_dep
                                                 (λ H0 : True,
                                                 ∀ e : [] = [],
                                                 eq_rect
                                                 {| pr1 := []; pr2 := [] |}
                                                 (λ index : 
                                                 sigma 
                                                 (λ _ : list A, list B),
                                                 All2 R 
                                                 (pr1 index) 
                                                 (pr2 index)) All2_nil
                                                 {| pr1 := []; pr2 := [] |}
                                                 (DepElim.pack_sigma_eq_nondep
                                                 match H0 with
                                                 | I => eq_refl
                                                 end e) = All2_nil
                                                 → 
                                                 apply_noConfusion [] []
                                                 (λ _ : True,
                                                 apply_noConfusion [] []
                                                 (λ _ : True, True)) eq_refl
                                                 eq_refl
                                                 → 
                                                 All2_nil = All2_nil)
                                                 (apply_noConfusion [] []
                                                 (Logic.True_rect_dep
                                                 (λ H0 : True,
                                                 eq_rect
                                                 {| pr1 := []; pr2 := [] |}
                                                 (λ index : 
                                                 sigma 
                                                 (λ _ : list A, list B),
                                                 All2 R 
                                                 (pr1 index) 
                                                 (pr2 index)) All2_nil
                                                 {| pr1 := []; pr2 := [] |}
                                                 match
                                                 match H0 with
                                                 | I => eq_refl
                                                 end in 
                                                 (_ = p)
                                                 return
                                                 ({| pr1 := []; pr2 := [] |} =
                                                 {| pr1 := []; pr2 := p |})
                                                 with
                                                 | eq_refl => eq_refl
                                                 end = All2_nil
                                                 → 
                                                 apply_noConfusion [] []
                                                 (λ _ : True,
                                                 apply_noConfusion [] []
                                                 (λ _ : True, True)) eq_refl
                                                 eq_refl
                                                 → 
                                                 All2_nil = All2_nil)
                                                 (λ H0 : All2_nil = All2_nil,
                                                 DepElim.solution_left
                                                 All2_nil
                                                 (λ H1 : 
                                                 apply_noConfusion [] []
                                                 (λ _ : True,
                                                 apply_noConfusion [] []
                                                 (λ _ : True, True)) eq_refl
                                                 eq_refl,
                                                 match H1 with
                                                 | I => eq_refl
                                                 end) All2_nil H0)))) eq_refl
                                                 eq_refl eq_refl H in 
                                                 (_ = p)
                                                 return
                                                 ({|
                                                 pr1 := []; pr2 := All2_nil
                                                 |} =
                                                 {| pr1 := []; pr2 := p |})
                                                 with
                                                 | eq_refl => eq_refl
                                                 end in 
                                                 (_ = p)
                                                 return
                                                 ({|
                                                 pr1 := [];
                                                 pr2 :=
                                                 {|
                                                 pr1 := []; pr2 := All2_nil
                                                 |}
                                                 |} =
                                                 {| pr1 := []; pr2 := p |})
                                                 with
                                                 | eq_refl => eq_refl
                                                 end = All2_dep_nil
                                                 → 
                                                 apply_noConfusion [] []
                                                 (Logic.True_rect_dep
                                                 (λ H0 : True,
                                                 eq_rect []
                                                 (λ xs : list A,
                                                 sigma
                                                 (λ ys : list B, All2 R xs ys))
                                                 {|
                                                 pr1 := []; pr2 := All2_nil
                                                 |} []
                                                 match H0 with
                                                 | I => eq_refl
                                                 end =
                                                 {|
                                                 pr1 := []; pr2 := All2_nil
                                                 |} → Prop)
                                                 (DepElim.eq_simplification_sigma1_dep
                                                 [] [] All2_nil All2_nil
                                                 (apply_noConfusion [] []
                                                 (Logic.True_rect_dep
                                                 (λ H0 : True,
                                                 eq_rect []
                                                 (λ ys : list B, All2 R [] ys)
                                                 All2_nil []
                                                 match H0 with
                                                 | I => eq_refl
                                                 end = All2_nil → Prop)
                                                 (apply_noConfusion All2_nil
                                                 All2_nil 
                                                 (λ _ : True, True))))))
                                                 eq_refl eq_refl
                                                 → 
                                                 All2_dep_nil = All2_dep_nil)
                                                (λ H : 
                                                 All2_dep_nil = All2_dep_nil,
                                                 DepElim.solution_left
                                                 All2_dep_nil
                                                 (λ H0 : 
                                                 apply_noConfusion [] []
                                                 (Logic.True_rect_dep
                                                 (λ H0 : True,
                                                 eq_rect []
                                                 (λ xs : list A,
                                                 sigma
                                                 (λ ys : list B, All2 R xs ys))
                                                 {|
                                                 pr1 := []; pr2 := All2_nil
                                                 |} []
                                                 match H0 with
                                                 | I => eq_refl
                                                 end =
                                                 {|
                                                 pr1 := []; pr2 := All2_nil
                                                 |} → Prop)
                                                 (DepElim.eq_simplification_sigma1_dep
                                                 [] [] All2_nil All2_nil
                                                 (apply_noConfusion [] []
                                                 (Logic.True_rect_dep
                                                 (λ H0 : True,
                                                 eq_rect []
                                                 (λ ys : list B, All2 R [] ys)
                                                 All2_nil []
                                                 match H0 with
                                                 | I => eq_refl
                                                 end = All2_nil → Prop)
                                                 (apply_noConfusion All2_nil
                                                 All2_nil 
                                                 (λ _ : True, True))))))
                                                 eq_refl eq_refl,
                                                 match H0 with
                                                 | I => eq_refl
                                                 end) All2_dep_nil H)))))))
                              eq_refl eq_refl eq_refl I)
DEBUG LTAC Evaluated term: eq_refl