Goal:
    A : Type  P : list A → list A → A → A → Type  Γ : list A
  ============================
   (All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ → All2_fold P Γ Γ)


DEBUG:Going to execute:
induction 1

Goals:
    A : Type  P : list A → list A → A → A → Type
  ============================
   (All2_fold P [] [])

  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (All2_fold P (d :: Γ) (d :: Γ))


DEBUG:Going to execute:
simpl

Goals:
    A : Type  P : list A → list A → A → A → Type
  ============================
   (All2_fold P [] [])

  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (All2_fold P (d :: Γ) (d :: Γ))


DEBUG:Going to execute:
constructor

Goals:
    A : Type  P : list A → list A → A → A → Type
  ============================
   (All2_fold P [] [])

  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (All2_fold P (d :: Γ) (d :: Γ))


DEBUG:Going to execute:
<coq-core.plugins.ltac::constructor@0>

Goals:
  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (All2_fold P Γ Γ)

  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (P Γ Γ d d)


DEBUG:Going to execute:
intuition auto; now rewrite <- (All2_fold_length X)

Goals:
  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (All2_fold P Γ Γ)

  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (P Γ Γ d d)


DEBUG:Going to execute:
auto; now rewrite <- (All2_fold_length X)

Goals:
  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (All2_fold P Γ Γ)

  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (P Γ Γ d d)


DEBUG:Going to execute:
<Coq.Init.Tauto.intuition_then> t

Goals:
  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (All2_fold P Γ Γ)

  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (P Γ Γ d d)


DEBUG:Going to execute:
fun tac =>
             <Coq.Init.Tauto.with_uniform_flags>
              ltac:(fun flags => <Coq.Init.Tauto.intuition_gen> flags tac)

Goals:
  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (All2_fold P Γ Γ)

  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (P Γ Γ d d)


DEBUG:Going to execute:
<Coq.Init.Tauto.with_uniform_flags>
            ltac:(fun flags => <Coq.Init.Tauto.intuition_gen> flags tac)

Goals:
  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (All2_fold P Γ Γ)

  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (P Γ Γ d d)


DEBUG:Going to execute:
fun f => <coq-core.plugins.tauto::with_uniform_flags@0>

Goals:
  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (All2_fold P Γ Γ)

  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (P Γ Γ d d)


DEBUG:Going to execute:
fun flags => <Coq.Init.Tauto.intuition_gen> flags tac

Goals:
  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (All2_fold P Γ Γ)

  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (P Γ Γ d d)


DEBUG:Going to execute:
<coq-core.plugins.tauto::with_uniform_flags@0>

Goals:
  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (All2_fold P Γ Γ)

  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (P Γ Γ d d)


DEBUG:Going to execute:
f x
Level 2: evaluation returns
<coq-core.plugins.tauto::with_uniform_flags@0>
where
f := fun flags => <Coq.Init.Tauto.intuition_gen> flags tac
     where
     tac := auto; now rewrite <- (All2_fold_length X)
     of type
     tacvalue
of type
tacvalue of type tacvalue

Level 2: evaluation returns
<coq-core.plugins.tauto::with_uniform_flags@0>
where
f := fun flags => <Coq.Init.Tauto.intuition_gen> flags tac
     where
     tac := auto; now rewrite <- (All2_fold_length X)
     of type
     tacvalue
of type
tacvalue of type tacvalue

Level 1: evaluation returns
<coq-core.plugins.tauto::with_uniform_flags@0>
where
f := fun flags => <Coq.Init.Tauto.intuition_gen> flags tac
     where
     tac := auto; now rewrite <- (All2_fold_length X)
     of type
     tacvalue
of type
tacvalue of type tacvalue

Level 1: evaluation returns
<coq-core.plugins.tauto::with_uniform_flags@0>
where
f := fun flags => <Coq.Init.Tauto.intuition_gen> flags tac
     where
     tac := auto; now rewrite <- (All2_fold_length X)
     of type
     tacvalue
of type
tacvalue of type tacvalue


Goals:
  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (All2_fold P Γ Γ)

  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (P Γ Γ d d)


DEBUG:Going to execute:
<Coq.Init.Tauto.intuition_gen> flags tac

Goals:
  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (All2_fold P Γ Γ)

  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (P Γ Γ d d)


DEBUG:Going to execute:
fun flags solver =>
             <Coq.Init.Tauto.tauto_intuit> flags
              ltac:(<Coq.Init.Tauto.reduction_not_iff>) solver

Goals:
  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (All2_fold P Γ Γ)

  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (P Γ Γ d d)


DEBUG:Going to execute:
<Coq.Init.Tauto.tauto_intuit> flags
            ltac:(<Coq.Init.Tauto.reduction_not_iff>) solver

Goals:
  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (All2_fold P Γ Γ)

  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (P Γ Γ d d)


DEBUG:Going to execute:
fun flags t_reduce t_solver =>
             let rec t_tauto_intuit :=
              <Coq.Init.Tauto.simplif> flags;
               <Coq.Init.Tauto.axioms> flags ||
                 match reverse goal with
                 | id:(?X1 → ?X2) → ?X3
                   |- _ =>
                       Ltac.cut X3;
                        [ intro; clear id; t_tauto_intuit
                        | Ltac.cut (X1 → X2);
                           [ exact
                           id
                           | generalize (λ y : X2, id (λ x : X1, y)); intro;
                              clear id; (solve [ t_tauto_intuit ]) ] ]
                 | id:¬ ?X1 → ?X3
                   |- _ =>
                       Ltac.cut X3;
                        [ intro; clear id; t_tauto_intuit
                        | Ltac.cut (¬ X1);
                           [ exact
                           id
                           | clear id; intro; (solve [ t_tauto_intuit ]) ] ]
                 | |- ?X1 =>
                       <Coq.Init.Tauto.is_disj> flags X1; (solve
                        [ Ltac.left; t_tauto_intuit
                        | Ltac.right; t_tauto_intuit ])
                 end ||
                   match goal with
                   | |- _ → _ => intro; t_tauto_intuit
                   | |- _ => t_reduce; t_solver
                   end || t_solver
             in
             t_tauto_intuit

Goals:
  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (All2_fold P Γ Γ)

  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (P Γ Γ d d)


DEBUG:Going to execute:
fun => <coq-core.plugins.tauto::reduction_not_iff@0>

Goals:
  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (All2_fold P Γ Γ)

  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (P Γ Γ d d)


DEBUG:Going to execute:
let rec t_tauto_intuit :=
            <Coq.Init.Tauto.simplif> flags;
             <Coq.Init.Tauto.axioms> flags ||
               match reverse goal with
               | id:(?X1 → ?X2) → ?X3
                 |- _ =>
                     Ltac.cut X3;
                      [ intro; clear id; t_tauto_intuit
                      | Ltac.cut (X1 → X2);
                         [ exact
                         id
                         | generalize (λ y : X2, id (λ x : X1, y)); intro;
                            clear id; (solve [ t_tauto_intuit ]) ] ]
               | id:¬ ?X1 → ?X3
                 |- _ =>
                     Ltac.cut X3;
                      [ intro; clear id; t_tauto_intuit
                      | Ltac.cut (¬ X1);
                         [ exact
                         id
                         | clear id; intro; (solve [ t_tauto_intuit ]) ] ]
               | |- ?X1 =>
                     <Coq.Init.Tauto.is_disj> flags X1; (solve
                      [ Ltac.left; t_tauto_intuit
                      | Ltac.right; t_tauto_intuit ])
               end ||
                 match goal with
                 | |- _ → _ => intro; t_tauto_intuit
                 | |- _ => t_reduce; t_solver
                 end || t_solver
           in
           t_tauto_intuit

Goals:
  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (All2_fold P Γ Γ)

  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (P Γ Γ d d)


DEBUG:Going to execute:
t_tauto_intuit

Goals:
  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (All2_fold P Γ Γ)

  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (P Γ Γ d d)


DEBUG:Going to execute:
<Coq.Init.Tauto.simplif> flags;
            <Coq.Init.Tauto.axioms> flags ||
              match reverse goal with
              | id:(?X1 → ?X2) → ?X3
                |- _ =>
                    Ltac.cut X3;
                     [ intro; clear id; t_tauto_intuit
                     | Ltac.cut (X1 → X2);
                        [ exact
                        id
                        | generalize (λ y : X2, id (λ x : X1, y)); intro;
                           clear id; (solve [ t_tauto_intuit ]) ] ]
              | id:¬ ?X1 → ?X3
                |- _ =>
                    Ltac.cut X3;
                     [ intro; clear id; t_tauto_intuit
                     | Ltac.cut (¬ X1);
                        [ exact
                        id
                        | clear id; intro; (solve [ t_tauto_intuit ]) ] ]
              | |- ?X1 =>
                    <Coq.Init.Tauto.is_disj> flags X1; (solve
                     [ Ltac.left; t_tauto_intuit
                     | Ltac.right; t_tauto_intuit ])
              end ||
                match goal with
                | |- _ → _ => intro; t_tauto_intuit
                | |- _ => t_reduce; t_solver
                end || t_solver

Goals:
  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (All2_fold P Γ Γ)

  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (P Γ Γ d d)


DEBUG:Going to execute:
<Coq.Init.Tauto.simplif> flags;
            <Coq.Init.Tauto.axioms> flags ||
              match reverse goal with
              | id:(?X1 → ?X2) → ?X3
                |- _ =>
                    Ltac.cut X3;
                     [ intro; clear id; t_tauto_intuit
                     | Ltac.cut (X1 → X2);
                        [ exact
                        id
                        | generalize (λ y : X2, id (λ x : X1, y)); intro;
                           clear id; (solve [ t_tauto_intuit ]) ] ]
              | id:¬ ?X1 → ?X3
                |- _ =>
                    Ltac.cut X3;
                     [ intro; clear id; t_tauto_intuit
                     | Ltac.cut (¬ X1);
                        [ exact
                        id
                        | clear id; intro; (solve [ t_tauto_intuit ]) ] ]
              | |- ?X1 =>
                    <Coq.Init.Tauto.is_disj> flags X1; (solve
                     [ Ltac.left; t_tauto_intuit
                     | Ltac.right; t_tauto_intuit ])
              end ||
                match goal with
                | |- _ → _ => intro; t_tauto_intuit
                | |- _ => t_reduce; t_solver
                end || t_solver

Goals:
  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (All2_fold P Γ Γ)

  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (P Γ Γ d d)


DEBUG:Going to execute:
<Coq.Init.Tauto.simplif> flags
Level 3: evaluation returns
<Coq.Init.Tauto.simplif> flags;
 <Coq.Init.Tauto.axioms> flags ||
   match reverse goal with
   | id:(?X1 → ?X2) → ?X3
     |- _ =>
         Ltac.cut X3;
          [ intro; clear id; t_tauto_intuit
          | Ltac.cut (X1 → X2);
             [ exact
             id
             | generalize (λ y : X2, id (λ x : X1, y)); intro; clear id;
                (solve [ t_tauto_intuit ]) ] ]
   | id:¬ ?X1 → ?X3
     |- _ =>
         Ltac.cut X3;
          [ intro; clear id; t_tauto_intuit
          | Ltac.cut (¬ X1);
             [ exact id | clear id; intro; (solve [ t_tauto_intuit ]) ] ]
   | |- ?X1 =>
         <Coq.Init.Tauto.is_disj> flags X1; (solve
          [ Ltac.left; t_tauto_intuit | Ltac.right; t_tauto_intuit ])
   end ||
     match goal with
     | |- _ → _ => intro; t_tauto_intuit
     | |- _ => t_reduce; t_solver
     end || t_solver
where
t_tauto_intuit := <tactic closure>
of type
tacvalue
t_solver := auto; now rewrite <- (All2_fold_length X)
of type
tacvalue
t_reduce := <coq-core.plugins.tauto::reduction_not_iff@0>
of type
tacvalue
flags := 
of type
tauto_flags of type tacvalue

Level 3: evaluation returns
<Coq.Init.Tauto.simplif> flags;
 <Coq.Init.Tauto.axioms> flags ||
   match reverse goal with
   | id:(?X1 → ?X2) → ?X3
     |- _ =>
         Ltac.cut X3;
          [ intro; clear id; t_tauto_intuit
          | Ltac.cut (X1 → X2);
             [ exact
             id
             | generalize (λ y : X2, id (λ x : X1, y)); intro; clear id;
                (solve [ t_tauto_intuit ]) ] ]
   | id:¬ ?X1 → ?X3
     |- _ =>
         Ltac.cut X3;
          [ intro; clear id; t_tauto_intuit
          | Ltac.cut (¬ X1);
             [ exact id | clear id; intro; (solve [ t_tauto_intuit ]) ] ]
   | |- ?X1 =>
         <Coq.Init.Tauto.is_disj> flags X1; (solve
          [ Ltac.left; t_tauto_intuit | Ltac.right; t_tauto_intuit ])
   end ||
     match goal with
     | |- _ → _ => intro; t_tauto_intuit
     | |- _ => t_reduce; t_solver
     end || t_solver
where
t_tauto_intuit := <tactic closure>
of type
tacvalue
t_solver := auto; now rewrite <- (All2_fold_length X)
of type
tacvalue
t_reduce := <coq-core.plugins.tauto::reduction_not_iff@0>
of type
tacvalue
flags := 
of type
tauto_flags of type tacvalue

Level 2: evaluation returns
<Coq.Init.Tauto.simplif> flags;
 <Coq.Init.Tauto.axioms> flags ||
   match reverse goal with
   | id:(?X1 → ?X2) → ?X3
     |- _ =>
         Ltac.cut X3;
          [ intro; clear id; t_tauto_intuit
          | Ltac.cut (X1 → X2);
             [ exact
             id
             | generalize (λ y : X2, id (λ x : X1, y)); intro; clear id;
                (solve [ t_tauto_intuit ]) ] ]
   | id:¬ ?X1 → ?X3
     |- _ =>
         Ltac.cut X3;
          [ intro; clear id; t_tauto_intuit
          | Ltac.cut (¬ X1);
             [ exact id | clear id; intro; (solve [ t_tauto_intuit ]) ] ]
   | |- ?X1 =>
         <Coq.Init.Tauto.is_disj> flags X1; (solve
          [ Ltac.left; t_tauto_intuit | Ltac.right; t_tauto_intuit ])
   end ||
     match goal with
     | |- _ → _ => intro; t_tauto_intuit
     | |- _ => t_reduce; t_solver
     end || t_solver
where
t_tauto_intuit := <tactic closure>
of type
tacvalue
t_solver := auto; now rewrite <- (All2_fold_length X)
of type
tacvalue
t_reduce := <coq-core.plugins.tauto::reduction_not_iff@0>
of type
tacvalue
flags := 
of type
tauto_flags of type tacvalue

Level 2: evaluation returns
<Coq.Init.Tauto.simplif> flags;
 <Coq.Init.Tauto.axioms> flags ||
   match reverse goal with
   | id:(?X1 → ?X2) → ?X3
     |- _ =>
         Ltac.cut X3;
          [ intro; clear id; t_tauto_intuit
          | Ltac.cut (X1 → X2);
             [ exact
             id
             | generalize (λ y : X2, id (λ x : X1, y)); intro; clear id;
                (solve [ t_tauto_intuit ]) ] ]
   | id:¬ ?X1 → ?X3
     |- _ =>
         Ltac.cut X3;
          [ intro; clear id; t_tauto_intuit
          | Ltac.cut (¬ X1);
             [ exact id | clear id; intro; (solve [ t_tauto_intuit ]) ] ]
   | |- ?X1 =>
         <Coq.Init.Tauto.is_disj> flags X1; (solve
          [ Ltac.left; t_tauto_intuit | Ltac.right; t_tauto_intuit ])
   end ||
     match goal with
     | |- _ → _ => intro; t_tauto_intuit
     | |- _ => t_reduce; t_solver
     end || t_solver
where
t_tauto_intuit := <tactic closure>
of type
tacvalue
t_solver := auto; now rewrite <- (All2_fold_length X)
of type
tacvalue
t_reduce := <coq-core.plugins.tauto::reduction_not_iff@0>
of type
tacvalue
flags := 
of type
tauto_flags of type tacvalue

Level 1: evaluation returns
<Coq.Init.Tauto.simplif> flags;
 <Coq.Init.Tauto.axioms> flags ||
   match reverse goal with
   | id:(?X1 → ?X2) → ?X3
     |- _ =>
         Ltac.cut X3;
          [ intro; clear id; t_tauto_intuit
          | Ltac.cut (X1 → X2);
             [ exact
             id
             | generalize (λ y : X2, id (λ x : X1, y)); intro; clear id;
                (solve [ t_tauto_intuit ]) ] ]
   | id:¬ ?X1 → ?X3
     |- _ =>
         Ltac.cut X3;
          [ intro; clear id; t_tauto_intuit
          | Ltac.cut (¬ X1);
             [ exact id | clear id; intro; (solve [ t_tauto_intuit ]) ] ]
   | |- ?X1 =>
         <Coq.Init.Tauto.is_disj> flags X1; (solve
          [ Ltac.left; t_tauto_intuit | Ltac.right; t_tauto_intuit ])
   end ||
     match goal with
     | |- _ → _ => intro; t_tauto_intuit
     | |- _ => t_reduce; t_solver
     end || t_solver
where
t_tauto_intuit := <tactic closure>
of type
tacvalue
t_solver := auto; now rewrite <- (All2_fold_length X)
of type
tacvalue
t_reduce := <coq-core.plugins.tauto::reduction_not_iff@0>
of type
tacvalue
flags := 
of type
tauto_flags of type tacvalue

Level 1: evaluation returns
<Coq.Init.Tauto.simplif> flags;
 <Coq.Init.Tauto.axioms> flags ||
   match reverse goal with
   | id:(?X1 → ?X2) → ?X3
     |- _ =>
         Ltac.cut X3;
          [ intro; clear id; t_tauto_intuit
          | Ltac.cut (X1 → X2);
             [ exact
             id
             | generalize (λ y : X2, id (λ x : X1, y)); intro; clear id;
                (solve [ t_tauto_intuit ]) ] ]
   | id:¬ ?X1 → ?X3
     |- _ =>
         Ltac.cut X3;
          [ intro; clear id; t_tauto_intuit
          | Ltac.cut (¬ X1);
             [ exact id | clear id; intro; (solve [ t_tauto_intuit ]) ] ]
   | |- ?X1 =>
         <Coq.Init.Tauto.is_disj> flags X1; (solve
          [ Ltac.left; t_tauto_intuit | Ltac.right; t_tauto_intuit ])
   end ||
     match goal with
     | |- _ → _ => intro; t_tauto_intuit
     | |- _ => t_reduce; t_solver
     end || t_solver
where
t_tauto_intuit := <tactic closure>
of type
tacvalue
t_solver := auto; now rewrite <- (All2_fold_length X)
of type
tacvalue
t_reduce := <coq-core.plugins.tauto::reduction_not_iff@0>
of type
tacvalue
flags := 
of type
tauto_flags of type tacvalue


Goals:
  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (All2_fold P Γ Γ)

  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (P Γ Γ d d)


DEBUG:Going to execute:
fun flags =>
             <Coq.Init.Tauto.not_dep_intros>;
              repeat
               (match reverse goal with
                | id:?X1
                  |- _ =>
                      <Coq.Init.Tauto.is_conj> flags X1; elim id; do 2 intro;
                       clear id
                | id:_ ↔ _ |- _ => elim id; do 2 intro; clear id
                | id:¬ _ |- _ => red in id
                | id:?X1
                  |- _ =>
                      <Coq.Init.Tauto.is_disj> flags X1; elim id; intro;
                       clear id
                | _ =>
                    <Coq.Init.Tauto.find_cut>
                     ltac:(fun id0 id1 X2 =>
                             assert X2; [ exact (id0 id1) | clear id0 ])
                | id:?X1 → ?X2
                  |- _ =>
                      <Coq.Init.Tauto.is_unit_or_eq> flags X1; Ltac.cut X2;
                       [ intro; clear id
                       | Ltac.cut X1; [ exact id | constructor 1; fail ] ]
                | id:?X1 → ?X2
                  |- _ =>
                      <Coq.Init.Tauto.flatten_contravariant_conj> flags X1 X2
                       id
                | id:?X1 ↔ ?X2 → ?X3
                  |- _ =>
                      assert ((X1 → X2) → (X2 → X1) → X3) by
                       (do 2 intro; apply id; Ltac.split; Ltac.assumption);
                       clear id
                | id:?X1 → ?X2
                  |- _ =>
                      <Coq.Init.Tauto.flatten_contravariant_disj> flags X1 X2
                       id
                | |- ?X1 => <Coq.Init.Tauto.is_conj> flags X1; Ltac.split
                | |- _ ↔ _ => Ltac.split
                | |- ¬ _ => red
                end; <Coq.Init.Tauto.not_dep_intros>)

Goals:
  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (All2_fold P Γ Γ)

  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (P Γ Γ d d)


DEBUG:Going to execute:
<Coq.Init.Tauto.not_dep_intros>;
            repeat
             (match reverse goal with
              | id:?X1
                |- _ =>
                    <Coq.Init.Tauto.is_conj> flags X1; elim id; do 2 intro;
                     clear id
              | id:_ ↔ _ |- _ => elim id; do 2 intro; clear id
              | id:¬ _ |- _ => red in id
              | id:?X1
                |- _ =>
                    <Coq.Init.Tauto.is_disj> flags X1; elim id; intro; clear
                     id
              | _ =>
                  <Coq.Init.Tauto.find_cut>
                   ltac:(fun id0 id1 X2 =>
                           assert X2; [ exact (id0 id1) | clear id0 ])
              | id:?X1 → ?X2
                |- _ =>
                    <Coq.Init.Tauto.is_unit_or_eq> flags X1; Ltac.cut X2;
                     [ intro; clear id
                     | Ltac.cut X1; [ exact id | constructor 1; fail ] ]
              | id:?X1 → ?X2
                |- _ =>
                    <Coq.Init.Tauto.flatten_contravariant_conj> flags X1 X2
                     id
              | id:?X1 ↔ ?X2 → ?X3
                |- _ =>
                    assert ((X1 → X2) → (X2 → X1) → X3) by
                     (do 2 intro; apply id; Ltac.split; Ltac.assumption);
                     clear id
              | id:?X1 → ?X2
                |- _ =>
                    <Coq.Init.Tauto.flatten_contravariant_disj> flags X1 X2
                     id
              | |- ?X1 => <Coq.Init.Tauto.is_conj> flags X1; Ltac.split
              | |- _ ↔ _ => Ltac.split
              | |- ¬ _ => red
              end; <Coq.Init.Tauto.not_dep_intros>)

Goals:
  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (All2_fold P Γ Γ)

  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (P Γ Γ d d)


DEBUG:Going to execute:
<Coq.Init.Tauto.not_dep_intros>
Level 1: evaluation returns
<Coq.Init.Tauto.not_dep_intros>;
 repeat
  (match reverse goal with
   | id:?X1
     |- _ => <Coq.Init.Tauto.is_conj> flags X1; elim id; do 2 intro; clear id
   | id:_ ↔ _ |- _ => elim id; do 2 intro; clear id
   | id:¬ _ |- _ => red in id
   | id:?X1
     |- _ => <Coq.Init.Tauto.is_disj> flags X1; elim id; intro; clear id
   | _ =>
       <Coq.Init.Tauto.find_cut>
        ltac:(fun id0 id1 X2 => assert X2; [ exact (id0 id1) | clear id0 ])
   | id:?X1 → ?X2
     |- _ =>
         <Coq.Init.Tauto.is_unit_or_eq> flags X1; Ltac.cut X2;
          [ intro; clear id
          | Ltac.cut X1; [ exact id | constructor 1; fail ] ]
   | id:?X1 → ?X2
     |- _ => <Coq.Init.Tauto.flatten_contravariant_conj> flags X1 X2 id
   | id:?X1 ↔ ?X2 → ?X3
     |- _ =>
         assert ((X1 → X2) → (X2 → X1) → X3) by
          (do 2 intro; apply id; Ltac.split; Ltac.assumption); clear id
   | id:?X1 → ?X2
     |- _ => <Coq.Init.Tauto.flatten_contravariant_disj> flags X1 X2 id
   | |- ?X1 => <Coq.Init.Tauto.is_conj> flags X1; Ltac.split
   | |- _ ↔ _ => Ltac.split
   | |- ¬ _ => red
   end; <Coq.Init.Tauto.not_dep_intros>)
where
flags := 
of type
tauto_flags of type tacvalue

Level 1: evaluation returns
<Coq.Init.Tauto.not_dep_intros>;
 repeat
  (match reverse goal with
   | id:?X1
     |- _ => <Coq.Init.Tauto.is_conj> flags X1; elim id; do 2 intro; clear id
   | id:_ ↔ _ |- _ => elim id; do 2 intro; clear id
   | id:¬ _ |- _ => red in id
   | id:?X1
     |- _ => <Coq.Init.Tauto.is_disj> flags X1; elim id; intro; clear id
   | _ =>
       <Coq.Init.Tauto.find_cut>
        ltac:(fun id0 id1 X2 => assert X2; [ exact (id0 id1) | clear id0 ])
   | id:?X1 → ?X2
     |- _ =>
         <Coq.Init.Tauto.is_unit_or_eq> flags X1; Ltac.cut X2;
          [ intro; clear id
          | Ltac.cut X1; [ exact id | constructor 1; fail ] ]
   | id:?X1 → ?X2
     |- _ => <Coq.Init.Tauto.flatten_contravariant_conj> flags X1 X2 id
   | id:?X1 ↔ ?X2 → ?X3
     |- _ =>
         assert ((X1 → X2) → (X2 → X1) → X3) by
          (do 2 intro; apply id; Ltac.split; Ltac.assumption); clear id
   | id:?X1 → ?X2
     |- _ => <Coq.Init.Tauto.flatten_contravariant_disj> flags X1 X2 id
   | |- ?X1 => <Coq.Init.Tauto.is_conj> flags X1; Ltac.split
   | |- _ ↔ _ => Ltac.split
   | |- ¬ _ => red
   end; <Coq.Init.Tauto.not_dep_intros>)
where
flags := 
of type
tauto_flags of type tacvalue


Goals:
  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (All2_fold P Γ Γ)

  
  A : Type
  P : list A → list A → A → A → Type
  d : A
  Γ : list A
  X : All_fold (λ (Γ : list A) (d : A), P Γ Γ d d) Γ
  p : P Γ Γ d d
  IHX : All2_fold P Γ Γ
  ============================
   (P Γ Γ d d)


DEBUG:Going to execute:
repeat
            match goal with
            | |- ?X1 → ?X2 => intro
            | |- ¬ _ => unfold not at 1; intro
            end