Goal:
  
  y1 : V.t
  x2 : V.t
  n2 : Z
  y2 : V.t
  H3 : CompareSpec (y1 = y2) (V.lt y1 y2) (V.lt y2 y1) (V.compare y1 y2)
  ============================
   (CompareSpec ((x2, n2, y1) = (x2, n2, y2))
      (V.lt x2 x2 \/
       V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)
      (V.lt x2 x2 \/
       V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1)
      (V.compare y1 y2))


DEBUG:Going to execute:
destruct (V.compare y1 y2)

Goals:
  
  y1 : V.t
  x2 : V.t
  n2 : Z
  y2 : V.t
  H3 : CompareSpec (y1 = y2) (V.lt y1 y2) (V.lt y2 y1) Eq
  ============================
   (CompareSpec ((x2, n2, y1) = (x2, n2, y2))
      (V.lt x2 x2 \/
       V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)
      (V.lt x2 x2 \/
       V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1) Eq)

  
  y1 : V.t
  x2 : V.t
  n2 : Z
  y2 : V.t
  H3 : CompareSpec (y1 = y2) (V.lt y1 y2) (V.lt y2 y1) Lt
  ============================
   (CompareSpec ((x2, n2, y1) = (x2, n2, y2))
      (V.lt x2 x2 \/
       V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)
      (V.lt x2 x2 \/
       V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1) Lt)

  
  y1 : V.t
  x2 : V.t
  n2 : Z
  y2 : V.t
  H3 : CompareSpec (y1 = y2) (V.lt y1 y2) (V.lt y2 y1) Gt
  ============================
   (CompareSpec ((x2, n2, y1) = (x2, n2, y2))
      (V.lt x2 x2 \/
       V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)
      (V.lt x2 x2 \/
       V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1) Gt)


DEBUG:Going to execute:
cbn in *
DEBUG LTAC Evaluated term: (V.compare y1 y2)

Goals:
  
  y1 : V.t
  x2 : V.t
  n2 : Z
  y2 : V.t
  H3 : CompareSpec (y1 = y2) (V.lt y1 y2) (V.lt y2 y1) Eq
  ============================
   (CompareSpec ((x2, n2, y1) = (x2, n2, y2))
      (V.lt x2 x2 \/
       V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)
      (V.lt x2 x2 \/
       V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1) Eq)

  
  y1 : V.t
  x2 : V.t
  n2 : Z
  y2 : V.t
  H3 : CompareSpec (y1 = y2) (V.lt y1 y2) (V.lt y2 y1) Lt
  ============================
   (CompareSpec ((x2, n2, y1) = (x2, n2, y2))
      (V.lt x2 x2 \/
       V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)
      (V.lt x2 x2 \/
       V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1) Lt)

  
  y1 : V.t
  x2 : V.t
  n2 : Z
  y2 : V.t
  H3 : CompareSpec (y1 = y2) (V.lt y1 y2) (V.lt y2 y1) Gt
  ============================
   (CompareSpec ((x2, n2, y1) = (x2, n2, y2))
      (V.lt x2 x2 \/
       V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)
      (V.lt x2 x2 \/
       V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1) Gt)


DEBUG:Going to execute:
inversion_clear H3

Goals:
    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : y1 = y2
  ============================
   (CompareSpec ((x2, n2, y1) = (x2, n2, y2))
      (V.lt x2 x2 \/
       V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)
      (V.lt x2 x2 \/
       V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1) Eq)

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y1 y2
  ============================
   (CompareSpec ((x2, n2, y1) = (x2, n2, y2))
      (V.lt x2 x2 \/
       V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)
      (V.lt x2 x2 \/
       V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1) Lt)

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y2 y1
  ============================
   (CompareSpec ((x2, n2, y1) = (x2, n2, y2))
      (V.lt x2 x2 \/
       V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)
      (V.lt x2 x2 \/
       V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1) Gt)


DEBUG:Going to execute:
constructor

Goals:
    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : y1 = y2
  ============================
   (CompareSpec ((x2, n2, y1) = (x2, n2, y2))
      (V.lt x2 x2 \/
       V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)
      (V.lt x2 x2 \/
       V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1) Eq)

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y1 y2
  ============================
   (CompareSpec ((x2, n2, y1) = (x2, n2, y2))
      (V.lt x2 x2 \/
       V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)
      (V.lt x2 x2 \/
       V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1) Lt)

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y2 y1
  ============================
   (CompareSpec ((x2, n2, y1) = (x2, n2, y2))
      (V.lt x2 x2 \/
       V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)
      (V.lt x2 x2 \/
       V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1) Gt)


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

Goals:
    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : y1 = y2
  ============================
   ((x2, n2, y1) = (x2, n2, y2))

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y1 y2
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y2 y1
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1)


DEBUG:Going to execute:
subst

Goals:
    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : y1 = y2
  ============================
   ((x2, n2, y1) = (x2, n2, y2))

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y1 y2
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y2 y1
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1)


DEBUG:Going to execute:
<coq-core.plugins.ltac::subst@1>

Goals:
    x2 : V.t  n2 : Z  y2 : V.t
  ============================
   ((x2, n2, y2) = (x2, n2, y2))

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y1 y2
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y2 y1
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1)


DEBUG:Going to execute:
intuition

Goals:
    x2 : V.t  n2 : Z  y2 : V.t
  ============================
   ((x2, n2, y2) = (x2, n2, y2))

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y1 y2
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y2 y1
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1)


DEBUG:Going to execute:
intuition

Goals:
    x2 : V.t  n2 : Z  y2 : V.t
  ============================
   ((x2, n2, y2) = (x2, n2, y2))

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y1 y2
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y2 y1
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1)


DEBUG:Going to execute:
<Coq.Init.Tauto.intuition_then> ltac:(idtac; intuition_solver)

Goals:
    x2 : V.t  n2 : Z  y2 : V.t
  ============================
   ((x2, n2, y2) = (x2, n2, y2))

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y1 y2
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y2 y1
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1)


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

Goals:
    x2 : V.t  n2 : Z  y2 : V.t
  ============================
   ((x2, n2, y2) = (x2, n2, y2))

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y1 y2
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y2 y1
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1)


DEBUG:Going to execute:
idtac; intuition_solver

Goals:
    x2 : V.t  n2 : Z  y2 : V.t
  ============================
   ((x2, n2, y2) = (x2, n2, y2))

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y1 y2
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y2 y1
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1)


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

Goals:
    x2 : V.t  n2 : Z  y2 : V.t
  ============================
   ((x2, n2, y2) = (x2, n2, y2))

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y1 y2
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y2 y1
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1)


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

Goals:
    x2 : V.t  n2 : Z  y2 : V.t
  ============================
   ((x2, n2, y2) = (x2, n2, y2))

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y1 y2
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y2 y1
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1)


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

Goals:
    x2 : V.t  n2 : Z  y2 : V.t
  ============================
   ((x2, n2, y2) = (x2, n2, y2))

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y1 y2
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y2 y1
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1)


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

Goals:
    x2 : V.t  n2 : Z  y2 : V.t
  ============================
   ((x2, n2, y2) = (x2, n2, y2))

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y1 y2
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y2 y1
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1)


DEBUG:Going to execute:
f x
Level 3: evaluation returns
<coq-core.plugins.tauto::with_uniform_flags@0>
where
f := fun flags => <Coq.Init.Tauto.intuition_gen> flags tac
     where
     tac := idtac; intuition_solver
     of type
     tacvalue
of type
tacvalue of type tacvalue

Level 3: evaluation returns
<coq-core.plugins.tauto::with_uniform_flags@0>
where
f := fun flags => <Coq.Init.Tauto.intuition_gen> flags tac
     where
     tac := idtac; intuition_solver
     of type
     tacvalue
of type
tacvalue of type tacvalue

Level 3: evaluation returns
<coq-core.plugins.tauto::with_uniform_flags@0>
where
f := fun flags => <Coq.Init.Tauto.intuition_gen> flags tac
     where
     tac := idtac; intuition_solver
     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 := idtac; intuition_solver
     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 := idtac; intuition_solver
     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 := idtac; intuition_solver
     of type
     tacvalue
of type
tacvalue of type tacvalue


Goals:
    x2 : V.t  n2 : Z  y2 : V.t
  ============================
   ((x2, n2, y2) = (x2, n2, y2))

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y1 y2
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y2 y1
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1)


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

Goals:
    x2 : V.t  n2 : Z  y2 : V.t
  ============================
   ((x2, n2, y2) = (x2, n2, y2))

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y1 y2
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y2 y1
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1)


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

Goals:
    x2 : V.t  n2 : Z  y2 : V.t
  ============================
   ((x2, n2, y2) = (x2, n2, y2))

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y1 y2
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y2 y1
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1)


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

Goals:
    x2 : V.t  n2 : Z  y2 : V.t
  ============================
   ((x2, n2, y2) = (x2, n2, y2))

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y1 y2
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y2 y1
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1)


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 (fun y : X2 => id (fun 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:
    x2 : V.t  n2 : Z  y2 : V.t
  ============================
   ((x2, n2, y2) = (x2, n2, y2))

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y1 y2
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y2 y1
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1)


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

Goals:
    x2 : V.t  n2 : Z  y2 : V.t
  ============================
   ((x2, n2, y2) = (x2, n2, y2))

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y1 y2
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y2 y1
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1)


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 (fun y : X2 => id (fun 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:
    x2 : V.t  n2 : Z  y2 : V.t
  ============================
   ((x2, n2, y2) = (x2, n2, y2))

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y1 y2
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y2 y1
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1)


DEBUG:Going to execute:
t_tauto_intuit

Goals:
    x2 : V.t  n2 : Z  y2 : V.t
  ============================
   ((x2, n2, y2) = (x2, n2, y2))

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y1 y2
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y2 y1
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1)


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 (fun y : X2 => id (fun 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:
    x2 : V.t  n2 : Z  y2 : V.t
  ============================
   ((x2, n2, y2) = (x2, n2, y2))

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y1 y2
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y2 y1
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1)


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 (fun y : X2 => id (fun 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:
    x2 : V.t  n2 : Z  y2 : V.t
  ============================
   ((x2, n2, y2) = (x2, n2, y2))

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y1 y2
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y2 y1
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1)


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 (fun y : X2 => id (fun 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 := idtac; intuition_solver
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 (fun y : X2 => id (fun 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 := idtac; intuition_solver
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 (fun y : X2 => id (fun 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 := idtac; intuition_solver
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 (fun y : X2 => id (fun 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 := idtac; intuition_solver
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 (fun y : X2 => id (fun 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 := idtac; intuition_solver
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 (fun y : X2 => id (fun 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 := idtac; intuition_solver
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 (fun y : X2 => id (fun 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 := idtac; intuition_solver
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 (fun y : X2 => id (fun 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 := idtac; intuition_solver
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 (fun y : X2 => id (fun 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 := idtac; intuition_solver
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:
    x2 : V.t  n2 : Z  y2 : V.t
  ============================
   ((x2, n2, y2) = (x2, n2, y2))

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y1 y2
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y2 y1
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1)


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:
    x2 : V.t  n2 : Z  y2 : V.t
  ============================
   ((x2, n2, y2) = (x2, n2, y2))

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y1 y2
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y2 y1
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1)


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:
    x2 : V.t  n2 : Z  y2 : V.t
  ============================
   ((x2, n2, y2) = (x2, n2, y2))

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y1 y2
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y2 y1
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1)


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

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:
    x2 : V.t  n2 : Z  y2 : V.t
  ============================
   ((x2, n2, y2) = (x2, n2, y2))

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y1 y2
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y1 y2)

    y1 : V.t  x2 : V.t  n2 : Z  y2 : V.t  H : V.lt y2 y1
  ============================
   (V.lt x2 x2 \/
    V.eq x2 x2 /\ n2 < n2 \/ V.eq x2 x2 /\ n2 = n2 /\ V.lt y2 y1)


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