Goal:
    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (#|(if f a then a :: filter f xs else filter f xs)| ≤ S #|xs|)


DEBUG:Going to execute:
destruct (f a)

Goals:
    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (#|a :: filter f xs| ≤ S #|xs|)

    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (#|filter f xs| ≤ S #|xs|)


DEBUG:Going to execute:
cbn
DEBUG LTAC Evaluated term: (f a)

Goals:
    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (S #|filter f xs| ≤ S #|xs|)

    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (#|filter f xs| ≤ S #|xs|)


DEBUG:Going to execute:
lia

Goals:
    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (S #|filter f xs| ≤ S #|xs|)

    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (#|filter f xs| ≤ S #|xs|)


DEBUG:Going to execute:
Zify.zify; xlia zchecker

Goals:
    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (S #|filter f xs| ≤ S #|xs|)

    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (#|filter f xs| ≤ S #|xs|)


DEBUG:Going to execute:
Zify.zify

Goals:
    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (S #|filter f xs| ≤ S #|xs|)

    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (#|filter f xs| ≤ S #|xs|)


DEBUG:Going to execute:
intros; Zify.zify_pre_hook; zify_elim_let; zify_op;
            Zify.zify_iter_specs; Zify.zify_to_euclidean_division_equations;
            Zify.zify_post_hook; zify_saturate

Goals:
    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (S #|filter f xs| ≤ S #|xs|)

    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (#|filter f xs| ≤ S #|xs|)


DEBUG:Going to execute:
intros; Zify.zify_pre_hook; zify_elim_let; zify_op;
            Zify.zify_iter_specs; Zify.zify_to_euclidean_division_equations;
            Zify.zify_post_hook

Goals:
    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (S #|filter f xs| ≤ S #|xs|)

    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (#|filter f xs| ≤ S #|xs|)


DEBUG:Going to execute:
intros; Zify.zify_pre_hook; zify_elim_let; zify_op;
            Zify.zify_iter_specs; Zify.zify_to_euclidean_division_equations

Goals:
    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (S #|filter f xs| ≤ S #|xs|)

    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (#|filter f xs| ≤ S #|xs|)


DEBUG:Going to execute:
intros; Zify.zify_pre_hook; zify_elim_let; zify_op;
            Zify.zify_iter_specs

Goals:
    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (S #|filter f xs| ≤ S #|xs|)

    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (#|filter f xs| ≤ S #|xs|)


DEBUG:Going to execute:
intros; Zify.zify_pre_hook; zify_elim_let; zify_op

Goals:
    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (S #|filter f xs| ≤ S #|xs|)

    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (#|filter f xs| ≤ S #|xs|)


DEBUG:Going to execute:
intros; Zify.zify_pre_hook; zify_elim_let

Goals:
    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (S #|filter f xs| ≤ S #|xs|)

    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (#|filter f xs| ≤ S #|xs|)


DEBUG:Going to execute:
intros; Zify.zify_pre_hook

Goals:
    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (S #|filter f xs| ≤ S #|xs|)

    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (#|filter f xs| ≤ S #|xs|)


DEBUG:Going to execute:
intros

Goals:
    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (S #|filter f xs| ≤ S #|xs|)

    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (#|filter f xs| ≤ S #|xs|)


DEBUG:Going to execute:
Zify.zify_pre_hook

Goals:
    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (S #|filter f xs| ≤ S #|xs|)

    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (#|filter f xs| ≤ S #|xs|)


DEBUG:Going to execute:
idtac

Goals:
    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (S #|filter f xs| ≤ S #|xs|)

    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (#|filter f xs| ≤ S #|xs|)


DEBUG:Going to execute:
zify_elim_let

Goals:
    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (S #|filter f xs| ≤ S #|xs|)

    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (#|filter f xs| ≤ S #|xs|)


DEBUG:Going to execute:
<coq-core.plugins.zify::TRANS@3>

Goals:
    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (S #|filter f xs| ≤ S #|xs|)

    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (#|filter f xs| ≤ S #|xs|)


DEBUG:Going to execute:
zify_op

Goals:
    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (S #|filter f xs| ≤ S #|xs|)

    X : Type  f : X → bool  a : X  xs : list X  IHxs : #|filter f xs| ≤ #|xs|
  ============================
   (#|filter f xs| ≤ S #|xs|)


DEBUG:Going to execute:
<coq-core.plugins.zify::TRANS@0>

Goals:
  
  X : Type
  f : X → bool
  a : X
  xs : list X
  IHxs : BinInt.Z.le (BinInt.Z.of_nat #|filter f xs|) (BinInt.Z.of_nat #|xs|)
  cstr : BinInt.Z.le BinNums.Z0 (BinInt.Z.of_nat #|xs|)
  cstr0 : BinInt.Z.le BinNums.Z0 (BinInt.Z.of_nat #|filter f xs|)
  ============================
   (BinInt.Z.le
      (BinInt.Z.add (BinInt.Z.of_nat #|filter f xs|)
         (BinNums.Zpos BinNums.xH))
      (BinInt.Z.add (BinInt.Z.of_nat #|xs|) (BinNums.Zpos BinNums.xH)))

  
  X : Type
  f : X → bool
  a : X
  xs : list X
  IHxs : BinInt.Z.le (BinInt.Z.of_nat #|filter f xs|) (BinInt.Z.of_nat #|xs|)
  cstr : BinInt.Z.le BinNums.Z0 (BinInt.Z.of_nat #|xs|)
  cstr0 : BinInt.Z.le BinNums.Z0 (BinInt.Z.of_nat #|filter f xs|)
  ============================
   (BinInt.Z.le (BinInt.Z.of_nat #|filter f xs|)
      (BinInt.Z.add (BinInt.Z.of_nat #|xs|) (BinNums.Zpos BinNums.xH)))


DEBUG:Going to execute:
Zify.zify_iter_specs

Goals:
  
  X : Type
  f : X → bool
  a : X
  xs : list X
  IHxs : BinInt.Z.le (BinInt.Z.of_nat #|filter f xs|) (BinInt.Z.of_nat #|xs|)
  cstr : BinInt.Z.le BinNums.Z0 (BinInt.Z.of_nat #|xs|)
  cstr0 : BinInt.Z.le BinNums.Z0 (BinInt.Z.of_nat #|filter f xs|)
  ============================
   (BinInt.Z.le
      (BinInt.Z.add (BinInt.Z.of_nat #|filter f xs|)
         (BinNums.Zpos BinNums.xH))
      (BinInt.Z.add (BinInt.Z.of_nat #|xs|) (BinNums.Zpos BinNums.xH)))

  
  X : Type
  f : X → bool
  a : X
  xs : list X
  IHxs : BinInt.Z.le (BinInt.Z.of_nat #|filter f xs|) (BinInt.Z.of_nat #|xs|)
  cstr : BinInt.Z.le BinNums.Z0 (BinInt.Z.of_nat #|xs|)
  cstr0 : BinInt.Z.le BinNums.Z0 (BinInt.Z.of_nat #|filter f xs|)
  ============================
   (BinInt.Z.le (BinInt.Z.of_nat #|filter f xs|)
      (BinInt.Z.add (BinInt.Z.of_nat #|xs|) (BinNums.Zpos BinNums.xH)))


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

Goals:
  
  X : Type
  f : X → bool
  a : X
  xs : list X
  IHxs : BinInt.Z.le (BinInt.Z.of_nat #|filter f xs|) (BinInt.Z.of_nat #|xs|)
  cstr : BinInt.Z.le BinNums.Z0 (BinInt.Z.of_nat #|xs|)
  cstr0 : BinInt.Z.le BinNums.Z0 (BinInt.Z.of_nat #|filter f xs|)
  ============================
   (BinInt.Z.le
      (BinInt.Z.add (BinInt.Z.of_nat #|filter f xs|)
         (BinNums.Zpos BinNums.xH))
      (BinInt.Z.add (BinInt.Z.of_nat #|xs|) (BinNums.Zpos BinNums.xH)))

  
  X : Type
  f : X → bool
  a : X
  xs : list X
  IHxs : BinInt.Z.le (BinInt.Z.of_nat #|filter f xs|) (BinInt.Z.of_nat #|xs|)
  cstr : BinInt.Z.le BinNums.Z0 (BinInt.Z.of_nat #|xs|)
  cstr0 : BinInt.Z.le BinNums.Z0 (BinInt.Z.of_nat #|filter f xs|)
  ============================
   (BinInt.Z.le (BinInt.Z.of_nat #|filter f xs|)
      (BinInt.Z.add (BinInt.Z.of_nat #|xs|) (BinNums.Zpos BinNums.xH)))


DEBUG:Going to execute:
Zify.zify_to_euclidean_division_equations

Goals:
  
  X : Type
  f : X → bool
  a : X
  xs : list X
  IHxs : BinInt.Z.le (BinInt.Z.of_nat #|filter f xs|) (BinInt.Z.of_nat #|xs|)
  cstr : BinInt.Z.le BinNums.Z0 (BinInt.Z.of_nat #|xs|)
  cstr0 : BinInt.Z.le BinNums.Z0 (BinInt.Z.of_nat #|filter f xs|)
  ============================
   (BinInt.Z.le
      (BinInt.Z.add (BinInt.Z.of_nat #|filter f xs|)
         (BinNums.Zpos BinNums.xH))
      (BinInt.Z.add (BinInt.Z.of_nat #|xs|) (BinNums.Zpos BinNums.xH)))

  
  X : Type
  f : X → bool
  a : X
  xs : list X
  IHxs : BinInt.Z.le (BinInt.Z.of_nat #|filter f xs|) (BinInt.Z.of_nat #|xs|)
  cstr : BinInt.Z.le BinNums.Z0 (BinInt.Z.of_nat #|xs|)
  cstr0 : BinInt.Z.le BinNums.Z0 (BinInt.Z.of_nat #|filter f xs|)
  ============================
   (BinInt.Z.le (BinInt.Z.of_nat #|filter f xs|)
      (BinInt.Z.add (BinInt.Z.of_nat #|xs|) (BinNums.Zpos BinNums.xH)))


DEBUG:Going to execute:
lazymatch Zify.zify_convert_to_euclidean_division_equations_flag
           with
           | true =>
               Zify.zify_internal_to_euclidean_division_equations
           | false => idtac
           end

Goals:
  
  X : Type
  f : X → bool
  a : X
  xs : list X
  IHxs : BinInt.Z.le (BinInt.Z.of_nat #|filter f xs|) (BinInt.Z.of_nat #|xs|)
  cstr : BinInt.Z.le BinNums.Z0 (BinInt.Z.of_nat #|xs|)
  cstr0 : BinInt.Z.le BinNums.Z0 (BinInt.Z.of_nat #|filter f xs|)
  ============================
   (BinInt.Z.le
      (BinInt.Z.add (BinInt.Z.of_nat #|filter f xs|)
         (BinNums.Zpos BinNums.xH))
      (BinInt.Z.add (BinInt.Z.of_nat #|xs|) (BinNums.Zpos BinNums.xH)))

  
  X : Type
  f : X → bool
  a : X
  xs : list X
  IHxs : BinInt.Z.le (BinInt.Z.of_nat #|filter f xs|) (BinInt.Z.of_nat #|xs|)
  cstr : BinInt.Z.le BinNums.Z0 (BinInt.Z.of_nat #|xs|)
  cstr0 : BinInt.Z.le BinNums.Z0 (BinInt.Z.of_nat #|filter f xs|)
  ============================
   (BinInt.Z.le (BinInt.Z.of_nat #|filter f xs|)
      (BinInt.Z.add (BinInt.Z.of_nat #|xs|) (BinNums.Zpos BinNums.xH)))


DEBUG:Going to execute:
Zify.zify_convert_to_euclidean_division_equations_flag

Goals:
  
  X : Type
  f : X → bool
  a : X
  xs : list X
  IHxs : BinInt.Z.le (BinInt.Z.of_nat #|filter f xs|) (BinInt.Z.of_nat #|xs|)
  cstr : BinInt.Z.le BinNums.Z0 (BinInt.Z.of_nat #|xs|)
  cstr0 : BinInt.Z.le BinNums.Z0 (BinInt.Z.of_nat #|filter f xs|)
  ============================
   (BinInt.Z.le
      (BinInt.Z.add (BinInt.Z.of_nat #|filter f xs|)
         (BinNums.Zpos BinNums.xH))
      (BinInt.Z.add (BinInt.Z.of_nat #|xs|) (BinNums.Zpos BinNums.xH)))

  
  X : Type
  f : X → bool
  a : X
  xs : list X
  IHxs : BinInt.Z.le (BinInt.Z.of_nat #|filter f xs|) (BinInt.Z.of_nat #|xs|)
  cstr : BinInt.Z.le BinNums.Z0 (BinInt.Z.of_nat #|xs|)
  cstr0 : BinInt.Z.le BinNums.Z0 (BinInt.Z.of_nat #|filter f xs|)
  ============================
   (BinInt.Z.le (BinInt.Z.of_nat #|filter f xs|)
      (BinInt.Z.add (BinInt.Z.of_nat #|xs|) (BinNums.Zpos BinNums.xH)))


DEBUG:Going to execute:
constr:(false)