Goal:
  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  ============================
   (True -> (0 <= 0)%nat)


DEBUG:Going to execute:
<coq-core.plugins.ltac::trivial@0> $1 $2

Goals:

DEBUG:Going to execute:
hnf

Goals:

DEBUG:Going to execute:
intros

Goals:

DEBUG:Going to execute:
solve
[ do
![ solve
 [ trivial | apply : eq_sym ; trivial ]
 | discriminate
 | contradiction
 | Ltac.split ]
| case not_locked_false_eq_true; Ltac.assumption
| match goal with
  | H:~ _ |- _ => solve [ case H; trivial ]
  end ]

Goals:
  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  ============================
   (0 <= Z.pos _p_ -> (0 <= Pos.to_nat _p_)%nat)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  ============================
   (Z.pos _p_ <= Z.pos _p1_ -> (Pos.to_nat _p_ <= Pos.to_nat _p1_)%nat)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  ============================
   (Z.neg _p_ <= Z.pos _p1_ -> (0 <= Pos.to_nat _p1_)%nat)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  ============================
   (True -> (0 <= Pos.to_nat _p_)%nat)


DEBUG:Going to execute:
lia

Goals:
  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  ============================
   (0 <= Z.pos _p_ -> (0 <= Pos.to_nat _p_)%nat)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  ============================
   (Z.pos _p_ <= Z.pos _p1_ -> (Pos.to_nat _p_ <= Pos.to_nat _p1_)%nat)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  ============================
   (Z.neg _p_ <= Z.pos _p1_ -> (0 <= Pos.to_nat _p1_)%nat)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  ============================
   (True -> (0 <= Pos.to_nat _p_)%nat)


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

Goals:
  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  ============================
   (0 <= Z.pos _p_ -> (0 <= Pos.to_nat _p_)%nat)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  ============================
   (Z.pos _p_ <= Z.pos _p1_ -> (Pos.to_nat _p_ <= Pos.to_nat _p1_)%nat)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  ============================
   (Z.neg _p_ <= Z.pos _p1_ -> (0 <= Pos.to_nat _p1_)%nat)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  ============================
   (True -> (0 <= Pos.to_nat _p_)%nat)


DEBUG:Going to execute:
Zify.zify

Goals:
  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  ============================
   (0 <= Z.pos _p_ -> (0 <= Pos.to_nat _p_)%nat)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  ============================
   (Z.pos _p_ <= Z.pos _p1_ -> (Pos.to_nat _p_ <= Pos.to_nat _p1_)%nat)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  ============================
   (Z.neg _p_ <= Z.pos _p1_ -> (0 <= Pos.to_nat _p1_)%nat)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  ============================
   (True -> (0 <= Pos.to_nat _p_)%nat)


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:
  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  ============================
   (0 <= Z.pos _p_ -> (0 <= Pos.to_nat _p_)%nat)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  ============================
   (Z.pos _p_ <= Z.pos _p1_ -> (Pos.to_nat _p_ <= Pos.to_nat _p1_)%nat)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  ============================
   (Z.neg _p_ <= Z.pos _p1_ -> (0 <= Pos.to_nat _p1_)%nat)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  ============================
   (True -> (0 <= Pos.to_nat _p_)%nat)


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:
  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  ============================
   (0 <= Z.pos _p_ -> (0 <= Pos.to_nat _p_)%nat)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  ============================
   (Z.pos _p_ <= Z.pos _p1_ -> (Pos.to_nat _p_ <= Pos.to_nat _p1_)%nat)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  ============================
   (Z.neg _p_ <= Z.pos _p1_ -> (0 <= Pos.to_nat _p1_)%nat)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  ============================
   (True -> (0 <= Pos.to_nat _p_)%nat)


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:
  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  ============================
   (0 <= Z.pos _p_ -> (0 <= Pos.to_nat _p_)%nat)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  ============================
   (Z.pos _p_ <= Z.pos _p1_ -> (Pos.to_nat _p_ <= Pos.to_nat _p1_)%nat)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  ============================
   (Z.neg _p_ <= Z.pos _p1_ -> (0 <= Pos.to_nat _p1_)%nat)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  ============================
   (True -> (0 <= Pos.to_nat _p_)%nat)


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

Goals:
  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  ============================
   (0 <= Z.pos _p_ -> (0 <= Pos.to_nat _p_)%nat)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  ============================
   (Z.pos _p_ <= Z.pos _p1_ -> (Pos.to_nat _p_ <= Pos.to_nat _p1_)%nat)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  ============================
   (Z.neg _p_ <= Z.pos _p1_ -> (0 <= Pos.to_nat _p1_)%nat)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  ============================
   (True -> (0 <= Pos.to_nat _p_)%nat)


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

Goals:
  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  ============================
   (0 <= Z.pos _p_ -> (0 <= Pos.to_nat _p_)%nat)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  ============================
   (Z.pos _p_ <= Z.pos _p1_ -> (Pos.to_nat _p_ <= Pos.to_nat _p1_)%nat)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  ============================
   (Z.neg _p_ <= Z.pos _p1_ -> (0 <= Pos.to_nat _p1_)%nat)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  ============================
   (True -> (0 <= Pos.to_nat _p_)%nat)


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

Goals:
  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  ============================
   (0 <= Z.pos _p_ -> (0 <= Pos.to_nat _p_)%nat)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  ============================
   (Z.pos _p_ <= Z.pos _p1_ -> (Pos.to_nat _p_ <= Pos.to_nat _p1_)%nat)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  ============================
   (Z.neg _p_ <= Z.pos _p1_ -> (0 <= Pos.to_nat _p1_)%nat)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  ============================
   (True -> (0 <= Pos.to_nat _p_)%nat)


DEBUG:Going to execute:
intros; Zify.zify_pre_hook

Goals:
  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  ============================
   (0 <= Z.pos _p_ -> (0 <= Pos.to_nat _p_)%nat)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  ============================
   (Z.pos _p_ <= Z.pos _p1_ -> (Pos.to_nat _p_ <= Pos.to_nat _p1_)%nat)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  ============================
   (Z.neg _p_ <= Z.pos _p1_ -> (0 <= Pos.to_nat _p1_)%nat)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  ============================
   (True -> (0 <= Pos.to_nat _p_)%nat)


DEBUG:Going to execute:
intros

Goals:
  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  H : 0 <= Z.pos _p_
  ============================
   (0 <= Pos.to_nat _p_)%nat

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  H : Z.pos _p_ <= Z.pos _p1_
  ============================
   (Pos.to_nat _p_ <= Pos.to_nat _p1_)%nat

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  H : Z.neg _p_ <= Z.pos _p1_
  ============================
   (0 <= Pos.to_nat _p1_)%nat

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  H : True
  ============================
   (0 <= Pos.to_nat _p_)%nat


DEBUG:Going to execute:
Zify.zify_pre_hook

Goals:
  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  H : 0 <= Z.pos _p_
  ============================
   (0 <= Pos.to_nat _p_)%nat

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  H : Z.pos _p_ <= Z.pos _p1_
  ============================
   (Pos.to_nat _p_ <= Pos.to_nat _p1_)%nat

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  H : Z.neg _p_ <= Z.pos _p1_
  ============================
   (0 <= Pos.to_nat _p1_)%nat

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  H : True
  ============================
   (0 <= Pos.to_nat _p_)%nat


DEBUG:Going to execute:
idtac

Goals:
  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  H : 0 <= Z.pos _p_
  ============================
   (0 <= Pos.to_nat _p_)%nat

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  H : Z.pos _p_ <= Z.pos _p1_
  ============================
   (Pos.to_nat _p_ <= Pos.to_nat _p1_)%nat

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  H : Z.neg _p_ <= Z.pos _p1_
  ============================
   (0 <= Pos.to_nat _p1_)%nat

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  H : True
  ============================
   (0 <= Pos.to_nat _p_)%nat


DEBUG:Going to execute:
zify_elim_let

Goals:
  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  H : 0 <= Z.pos _p_
  ============================
   (0 <= Pos.to_nat _p_)%nat

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  H : Z.pos _p_ <= Z.pos _p1_
  ============================
   (Pos.to_nat _p_ <= Pos.to_nat _p1_)%nat

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  H : Z.neg _p_ <= Z.pos _p1_
  ============================
   (0 <= Pos.to_nat _p1_)%nat

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  H : True
  ============================
   (0 <= Pos.to_nat _p_)%nat


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

Goals:
  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  H : 0 <= Z.pos _p_
  ============================
   (0 <= Pos.to_nat _p_)%nat

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  H : Z.pos _p_ <= Z.pos _p1_
  ============================
   (Pos.to_nat _p_ <= Pos.to_nat _p1_)%nat

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  H : Z.neg _p_ <= Z.pos _p1_
  ============================
   (0 <= Pos.to_nat _p1_)%nat

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  H : True
  ============================
   (0 <= Pos.to_nat _p_)%nat


DEBUG:Going to execute:
zify_op

Goals:
  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  H : 0 <= Z.pos _p_
  ============================
   (0 <= Pos.to_nat _p_)%nat

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  H : Z.pos _p_ <= Z.pos _p1_
  ============================
   (Pos.to_nat _p_ <= Pos.to_nat _p1_)%nat

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  H : Z.neg _p_ <= Z.pos _p1_
  ============================
   (0 <= Pos.to_nat _p1_)%nat

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  H : True
  ============================
   (0 <= Pos.to_nat _p_)%nat


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

Goals:
  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  H : 0 <= Z.pos _p_
  cstr : 0 < Z.pos _p_
  ============================
   (0 <= Z.pos _p_)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  H : Z.pos _p_ <= Z.pos _p1_
  cstr : 0 < Z.pos _p_
  cstr0 : 0 < Z.pos _p1_
  ============================
   (Z.pos _p_ <= Z.pos _p1_)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  H : - Z.pos _p_ <= Z.pos _p1_
  cstr : 0 < Z.pos _p_
  cstr0 : 0 < Z.pos _p1_
  ============================
   (0 <= Z.pos _p1_)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  H : True
  cstr : 0 < Z.pos _p_
  ============================
   (0 <= Z.pos _p_)


DEBUG:Going to execute:
Zify.zify_iter_specs

Goals:
  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  H : 0 <= Z.pos _p_
  cstr : 0 < Z.pos _p_
  ============================
   (0 <= Z.pos _p_)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  H : Z.pos _p_ <= Z.pos _p1_
  cstr : 0 < Z.pos _p_
  cstr0 : 0 < Z.pos _p1_
  ============================
   (Z.pos _p_ <= Z.pos _p1_)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  H : - Z.pos _p_ <= Z.pos _p1_
  cstr : 0 < Z.pos _p_
  cstr0 : 0 < Z.pos _p1_
  ============================
   (0 <= Z.pos _p1_)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  H : True
  cstr : 0 < Z.pos _p_
  ============================
   (0 <= Z.pos _p_)


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

Goals:
  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  H : 0 <= Z.pos _p_
  cstr : 0 < Z.pos _p_
  ============================
   (0 <= Z.pos _p_)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  H : Z.pos _p_ <= Z.pos _p1_
  cstr : 0 < Z.pos _p_
  cstr0 : 0 < Z.pos _p1_
  ============================
   (Z.pos _p_ <= Z.pos _p1_)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  H : - Z.pos _p_ <= Z.pos _p1_
  cstr : 0 < Z.pos _p_
  cstr0 : 0 < Z.pos _p1_
  ============================
   (0 <= Z.pos _p1_)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  H : True
  cstr : 0 < Z.pos _p_
  ============================
   (0 <= Z.pos _p_)


DEBUG:Going to execute:
Zify.zify_to_euclidean_division_equations

Goals:
  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  H : 0 <= Z.pos _p_
  cstr : 0 < Z.pos _p_
  ============================
   (0 <= Z.pos _p_)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  H : Z.pos _p_ <= Z.pos _p1_
  cstr : 0 < Z.pos _p_
  cstr0 : 0 < Z.pos _p1_
  ============================
   (Z.pos _p_ <= Z.pos _p1_)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  H : - Z.pos _p_ <= Z.pos _p1_
  cstr : 0 < Z.pos _p_
  cstr0 : 0 < Z.pos _p1_
  ============================
   (0 <= Z.pos _p1_)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  H : True
  cstr : 0 < Z.pos _p_
  ============================
   (0 <= Z.pos _p_)


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:
  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  H : 0 <= Z.pos _p_
  cstr : 0 < Z.pos _p_
  ============================
   (0 <= Z.pos _p_)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  H : Z.pos _p_ <= Z.pos _p1_
  cstr : 0 < Z.pos _p_
  cstr0 : 0 < Z.pos _p1_
  ============================
   (Z.pos _p_ <= Z.pos _p1_)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  H : - Z.pos _p_ <= Z.pos _p1_
  cstr : 0 < Z.pos _p_
  cstr0 : 0 < Z.pos _p1_
  ============================
   (0 <= Z.pos _p1_)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  H : True
  cstr : 0 < Z.pos _p_
  ============================
   (0 <= Z.pos _p_)


DEBUG:Going to execute:
Zify.zify_convert_to_euclidean_division_equations_flag

Goals:
  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  H : 0 <= Z.pos _p_
  cstr : 0 < Z.pos _p_
  ============================
   (0 <= Z.pos _p_)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  H : Z.pos _p_ <= Z.pos _p1_
  cstr : 0 < Z.pos _p_
  cstr0 : 0 < Z.pos _p1_
  ============================
   (Z.pos _p_ <= Z.pos _p1_)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  _p1_ : positive
  H : - Z.pos _p_ <= Z.pos _p1_
  cstr : 0 < Z.pos _p_
  cstr0 : 0 < Z.pos _p1_
  ============================
   (0 <= Z.pos _p1_)

  
  G : t
  invG : invariants G
  acG : acyclic_no_loop G
  x : V.t
  y : V.t
  hx : VSet.In x (V G)
  hy : VSet.In y (V G)
  nxy : Z
  hxy : (lsp G x y <= Some nxy)%nbar
  _p_ : positive
  H : True
  cstr : 0 < Z.pos _p_
  ============================
   (0 <= Z.pos _p_)


DEBUG:Going to execute:
constr:(false)