TraversableFunctor.v

From Tealeaves Require Export
  Classes.Kleisli.TraversableFunctor
  Classes.Kleisli.Theory.TraversableFunctor
  Classes.Categorical.ContainerFunctor
  Classes.Categorical.ShapelyFunctor
  Classes.Categorical.ApplicativeCommutativeIdempotent
  Adapters.KleisliToCoalgebraic.TraversableFunctor
  Functors.Batch
  Functors.List
  Functors.VectorRefinement.

Import Coalgebraic.TraversableFunctor (ToBatch, toBatch).
Import KleisliToCoalgebraic.TraversableFunctor.DerivedInstances.

Import Subset.Notations.
Import Applicative.Notations.
Import ContainerFunctor.Notations.
Import ProductFunctor.Notations.
Import Kleisli.TraversableFunctor.Notations.
Import Batch.Notations.
Import Monoid.Notations.
Import VectorRefinement.Notations.

#[local] Generalizable Variables F T G A B C M ϕ.

#[local] Arguments mapfst_Batch {B C A1 A2}%type_scope
  f%function_scope b.
#[local] Arguments mapsnd_Batch {A B1 B2 C}%type_scope
  f%function_scope b.


(** * Miscellaneous Properties Concerning <<toBatch>> *)
(**********************************************************************)
Section stuff.

  Import Adapters.KleisliToCoalgebraic.TraversableFunctor.

  Context
    `{Kleisli.TraversableFunctor.TraversableFunctor T}
    `{Map T}
    `{ToBatch T}
    `{! Compat_Map_Traverse T}
    `{! Compat_ToBatch_Traverse T}.

  (** ** Relating <<tolist>> and <<Batch_contents ∘ toBatch>> *)
  (********************************************************************)
  Lemma Batch_contents_tolist:
    forall {A B} (t: T A),
      proj1_sig (Batch_contents (toBatch (A' := B) t)) =
        List.rev (tolist t).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A B : Type) (t : T A),
proj1_sig (Batch_contents (toBatch t)) =
List.rev (tolist t)
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A B : Type) (t : T A),
proj1_sig (Batch_contents (toBatch t)) =
List.rev (tolist t)
    intros.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
proj1_sig (Batch_contents (toBatch t)) =
List.rev (tolist t)
    rewrite tolist_Batch_contents.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
List.rev (tolist (toBatch t)) = List.rev (tolist t)
    rewrite <- tolist_through_toBatch.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
List.rev (tolist t) = List.rev (tolist t)
    reflexivity.
  Qed.

  (** ** Naturality of <<toBatch>> *)
  (********************************************************************)
  Corollary shape_natural_toBatch {A A'}: forall (t: T A),
      toBatch (A' := A') (shape t) =
        shape (F := BATCH1 A' (T A')) (toBatch (A' := A') t).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, A': Type
forall t : T A, toBatch (shape t) = shape (toBatch t)
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, A': Type
forall t : T A, toBatch (shape t) = shape (toBatch t)
    intros.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, A': Type
t: T A
toBatch (shape t) = shape (toBatch t) unfold shape.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, A': Type
t: T A
toBatch (map (const tt) t) =
map (const tt) (toBatch t) compose near t.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, A': Type
t: T A
(toBatch ∘ map (const tt)) t =
(map (const tt) ∘ toBatch) t
    now rewrite toBatch_mapfst.
  Qed.

  Corollary shape_toBatch_spec {A}: forall (t: T A),
      shape t = runBatch (G := fun A => A) (const tt)
                  (toBatch (A' := unit) (T := T) t).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
forall t : T A,
shape t = runBatch (const tt) (toBatch t)
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
forall t : T A,
shape t = runBatch (const tt) (toBatch t)
    intros.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
shape t = runBatch (const tt) (toBatch t)
    unfold shape.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
map (const tt) t = runBatch (const tt) (toBatch t)
    rewrite map_through_runBatch.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
(runBatch (const tt) ∘ toBatch) t =
runBatch (const tt) (toBatch t)
    reflexivity.
  Qed.

  (* This statement holds without a A' universally quantified
     inside the iff, but this is harder to prove. *)
  Lemma toBatch_injective_univ {A}: forall (t u: T A),
      (forall (A': Type), toBatch (A' := A') t = toBatch u) <-> t = u.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
forall t u : T A,
(forall A' : Type, toBatch t = toBatch u) <-> t = u
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
forall t u : T A,
(forall A' : Type, toBatch t = toBatch u) <-> t = u
    intros.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t, u: T A
(forall A' : Type, toBatch t = toBatch u) <-> t = u split.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t, u: T A
(forall A' : Type, toBatch t = toBatch u) -> t = u
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t, u: T A
t = u -> forall A' : Type, toBatch t = toBatch u
    -T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t, u: T A
(forall A' : Type, toBatch t = toBatch u) -> t = u intro HBatch.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t, u: T A
HBatch: forall A' : Type, toBatch t = toBatch u
t = u
      change (id t = id u).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t, u: T A
HBatch: forall A' : Type, toBatch t = toBatch u
id t = id u
      rewrite id_through_runBatch.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t, u: T A
HBatch: forall A' : Type, toBatch t = toBatch u
(runBatch id ∘ toBatch) t = (runBatch id ∘ toBatch) u
      unfold compose.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t, u: T A
HBatch: forall A' : Type, toBatch t = toBatch u
runBatch id (toBatch t) = runBatch id (toBatch u)
      rewrite HBatch.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t, u: T A
HBatch: forall A' : Type, toBatch t = toBatch u
runBatch id (toBatch u) = runBatch id (toBatch u)
      reflexivity.
    -T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t, u: T A
t = u -> forall A' : Type, toBatch t = toBatch u intro; now subst.
  Qed.

  (** ** <<Batch_contents ∘ toBatch>> is Independent of <<B>> *)
  (********************************************************************)
  Lemma Batch_contents_toBatch_sim:
    forall {A B B': Type} (t: T A),
      Batch_contents (toBatch (A' := B) t)
      ~~ Batch_contents (toBatch (A' := B') t).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A B B' : Type) (t : T A),
Batch_contents (toBatch t) ~~
Batch_contents (toBatch t)
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A B B' : Type) (t : T A),
Batch_contents (toBatch t) ~~
Batch_contents (toBatch t)
    intros.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, B': Type
t: T A
Batch_contents (toBatch t) ~~
Batch_contents (toBatch t)
    unfold Vector_sim.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, B': Type
t: T A
proj1_sig (Batch_contents (toBatch t)) =
proj1_sig (Batch_contents (toBatch t))
    rewrite Batch_contents_tolist.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, B': Type
t: T A
List.rev (tolist t) =
proj1_sig (Batch_contents (toBatch t))
    rewrite Batch_contents_tolist.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, B': Type
t: T A
List.rev (tolist t) = List.rev (tolist t)
    reflexivity.
  Qed.

  (** *** Terms with the same <<shape>> have <<toBatch>> of the same shape *)
  (********************************************************************)
  Lemma same_shape_toBatch:
    forall {A' B} `(t1: T A) (t2: T A'),
      shape t1 = shape t2 ->
      shape (F := BATCH1 B (T B))
        (toBatch (A' := B) t1) =
        shape (F := BATCH1 B (T B))
          (toBatch (A' := B) t2).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A' B A : Type) (t1 : T A) (t2 : T A'),
shape t1 = shape t2 ->
shape (toBatch t1) = shape (toBatch t2)
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A' B A : Type) (t1 : T A) (t2 : T A'),
shape t1 = shape t2 ->
shape (toBatch t1) = shape (toBatch t2)
    introv Hshape.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A', B, A: Type
t1: T A
t2: T A'
Hshape: shape t1 = shape t2
shape (toBatch t1) = shape (toBatch t2)
    rewrite <- shape_natural_toBatch.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A', B, A: Type
t1: T A
t2: T A'
Hshape: shape t1 = shape t2
toBatch (shape t1) = shape (toBatch t2)
    rewrite <- shape_natural_toBatch.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A', B, A: Type
t1: T A
t2: T A'
Hshape: shape t1 = shape t2
toBatch (shape t1) = toBatch (shape t2)
    rewrite Hshape.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A', B, A: Type
t1: T A
t2: T A'
Hshape: shape t1 = shape t2
toBatch (shape t2) = toBatch (shape t2)
    reflexivity.
  Qed.

  (** *** Terms with the same <<tolist>> terms have <<toBatch>> of the same <<tolist>>s*)
  (********************************************************************)
  Lemma same_tolist_toBatch:
    forall {B1 B2: Type} `(t1: T A) (t2: T A),
      tolist t1 = tolist t2 ->
      tolist (toBatch (A' := B1) t1) =
        tolist (toBatch (A' := B2) t2).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (B1 B2 A : Type) (t1 t2 : T A),
tolist t1 = tolist t2 ->
tolist (toBatch t1) = tolist (toBatch t2)
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (B1 B2 A : Type) (t1 t2 : T A),
tolist t1 = tolist t2 ->
tolist (toBatch t1) = tolist (toBatch t2)
    introv Hshape.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
B1, B2, A: Type
t1, t2: T A
Hshape: tolist t1 = tolist t2
tolist (toBatch t1) = tolist (toBatch t2)
    rewrite (tolist_through_toBatch B1) in Hshape.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
B1, B2, A: Type
t1, t2: T A
Hshape: tolist (toBatch t1) = tolist t2
tolist (toBatch t1) = tolist (toBatch t2)
    rewrite (tolist_through_toBatch (T := T) B2) in Hshape.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
B1, B2, A: Type
t1, t2: T A
Hshape: tolist (toBatch t1) = tolist (toBatch t2)
tolist (toBatch t1) = tolist (toBatch t2)
    assumption.
  Qed.


  (** ** Equal <<toBatch>> Implies Equal <<tolist>> *)
  (********************************************************************)
  Lemma toBatch_injective_tolist:
    forall {A B} `(t1: T A) (t2: T A),
      (toBatch (A' := B) t1) =
        (toBatch (A' := B) t2) ->
      tolist t1 = tolist t2.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A B : Type) (t1 t2 : T A),
toBatch t1 = toBatch t2 -> tolist t1 = tolist t2
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A B : Type) (t1 t2 : T A),
toBatch t1 = toBatch t2 -> tolist t1 = tolist t2
    introv Heq.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t1, t2: T A
Heq: toBatch t1 = toBatch t2
tolist t1 = tolist t2
    rewrite (tolist_through_toBatch B).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t1, t2: T A
Heq: toBatch t1 = toBatch t2
tolist (toBatch t1) = tolist t2
    rewrite (tolist_through_toBatch (T := T) B).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t1, t2: T A
Heq: toBatch t1 = toBatch t2
tolist (toBatch t1) = tolist (toBatch t2)
    rewrite Heq.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t1, t2: T A
Heq: toBatch t1 = toBatch t2
tolist (toBatch t2) = tolist (toBatch t2)
    reflexivity.
  Qed.

  (** ** Similar <<shape>>d <<toBatch>> implies similar <<shape>>s*)
  (********************************************************************)
  Lemma toBatch_shape_inv:
    forall {A' B} `(t1: T A) (t2: T A'),
      shape (F := BATCH1 B (T B))
        (toBatch (A' := B) t1) =
        shape (F := BATCH1 B (T B))
          (toBatch (A' := B) t2) ->
      shape t1 = shape t2.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A' B A : Type) (t1 : T A) (t2 : T A'),
shape (toBatch t1) = shape (toBatch t2) ->
shape t1 = shape t2
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A' B A : Type) (t1 : T A) (t2 : T A'),
shape (toBatch t1) = shape (toBatch t2) ->
shape t1 = shape t2
    introv.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A', B, A: Type
t1: T A
t2: T A'
shape (toBatch t1) = shape (toBatch t2) ->
shape t1 = shape t2
    intro HBatch.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A', B, A: Type
t1: T A
t2: T A'
HBatch: shape (toBatch t1) = shape (toBatch t2)
shape t1 = shape t2
    rewrite <- shape_natural_toBatch in HBatch.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A', B, A: Type
t1: T A
t2: T A'
HBatch: toBatch (shape t1) = shape (toBatch t2)
shape t1 = shape t2
    rewrite <- shape_natural_toBatch in HBatch.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A', B, A: Type
t1: T A
t2: T A'
HBatch: toBatch (shape t1) = toBatch (shape t2)
shape t1 = shape t2
    unfold shape.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A', B, A: Type
t1: T A
t2: T A'
HBatch: toBatch (shape t1) = toBatch (shape t2)
map (const tt) t1 = map (const tt) t2
  Abort.

  Lemma toBatch_injective_shape:
    forall {A B} `(t1: T A) (t2: T A),
      (toBatch (A' := B) t1) =
        (toBatch (A' := B) t2) ->
      shape t1 = shape t2.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A B : Type) (t1 t2 : T A),
toBatch t1 = toBatch t2 -> shape t1 = shape t2
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A B : Type) (t1 t2 : T A),
toBatch t1 = toBatch t2 -> shape t1 = shape t2
    introv Heq.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t1, t2: T A
Heq: toBatch t1 = toBatch t2
shape t1 = shape t2
    unfold shape at 1 2.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t1, t2: T A
Heq: toBatch t1 = toBatch t2
map (const tt) t1 = map (const tt) t2
  Abort.


  Lemma toBatch_injective_tolist2:
    forall {A B} `(t1: T A) (t2: T A),
      (toBatch (A' := B) t1) =
        (toBatch (A' := B) t2) <->
        tolist t1 = tolist t2.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A B : Type) (t1 t2 : T A),
toBatch t1 = toBatch t2 <-> tolist t1 = tolist t2
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A B : Type) (t1 t2 : T A),
toBatch t1 = toBatch t2 <-> tolist t1 = tolist t2
    intros.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t1, t2: T A
toBatch t1 = toBatch t2 <-> tolist t1 = tolist t2 split.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t1, t2: T A
toBatch t1 = toBatch t2 -> tolist t1 = tolist t2
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t1, t2: T A
tolist t1 = tolist t2 -> toBatch t1 = toBatch t2
    -T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t1, t2: T A
toBatch t1 = toBatch t2 -> tolist t1 = tolist t2 apply toBatch_injective_tolist.
    -T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t1, t2: T A
tolist t1 = tolist t2 -> toBatch t1 = toBatch t2 rewrite (tolist_through_toBatch B).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t1, t2: T A
tolist (toBatch t1) = tolist t2 ->
toBatch t1 = toBatch t2
      rewrite (tolist_through_toBatch (T := T) B).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t1, t2: T A
tolist (toBatch t1) = tolist (toBatch t2) ->
toBatch t1 = toBatch t2
  Abort.

  Lemma toBatch_injective:
    forall {A B} `(t1: T A) (t2: T A),
        (toBatch (A' := B) t1) =
          (toBatch (A' := B) t2) ->
        t1 = t2.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A B : Type) (t1 t2 : T A),
toBatch t1 = toBatch t2 -> t1 = t2
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A B : Type) (t1 t2 : T A),
toBatch t1 = toBatch t2 -> t1 = t2
    introv Heq.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t1, t2: T A
Heq: toBatch t1 = toBatch t2
t1 = t2
    change (id t1 = id t2).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t1, t2: T A
Heq: toBatch t1 = toBatch t2
id t1 = id t2
    rewrite id_through_runBatch.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t1, t2: T A
Heq: toBatch t1 = toBatch t2
(runBatch id ∘ toBatch) t1 =
(runBatch id ∘ toBatch) t2
    unfold compose.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t1, t2: T A
Heq: toBatch t1 = toBatch t2
runBatch id (toBatch t1) = runBatch id (toBatch t2)
  Abort.

End stuff.

(** * Length of <<toBatch>> is polymorphic *)
(**********************************************************************)
Lemma length_Batch_independent
  `{TraversableFunctor T}
  `{ToBatch T}
  `{Map T}
  `{! Compat_Map_Traverse T}
  `{! Compat_ToBatch_Traverse T}
 : forall `(t: T A) B C,
    length_Batch (toBatch (A' := B) t) =
      length_Batch (toBatch (A' := C) t).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: ToBatch T
H1: Map T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A : Type) (t : T A) (B C : Type),
length_Batch (toBatch t) = length_Batch (toBatch t)
Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: ToBatch T
H1: Map T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A : Type) (t : T A) (B C : Type),
length_Batch (toBatch t) = length_Batch (toBatch t)
Abort.

(** * Traversable Functors are Containers *)
(**********************************************************************)

(** ** Traversable Functors are Shapely *)
(**********************************************************************)
Section shapeliness.

  Context
    `{TraversableFunctor T}
    `{Map T}
    `{ToBatch T}
    `{! Compat_Map_Traverse T}
    `{! Compat_ToBatch_Traverse T}
    `{! ToSubset T} `{! Functor T}
    `{! Compat_ToSubset_Traverse T}.

  Theorem Traversable_shapeliness: forall A (t1 t2: T A),
      shape t1 = shape t2 /\ tolist t1 = tolist t2 ->
      t1 = t2.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
forall (A : Type) (t1 t2 : T A),
shape t1 = shape t2 /\ tolist t1 = tolist t2 ->
t1 = t2
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
forall (A : Type) (t1 t2 : T A),
shape t1 = shape t2 /\ tolist t1 = tolist t2 ->
t1 = t2
    introv [hyp1 hyp2].T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A: Type
t1, t2: T A
hyp1: shape t1 = shape t2
hyp2: tolist t1 = tolist t2
t1 = t2
    change (id t1 = id t2).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A: Type
t1, t2: T A
hyp1: shape t1 = shape t2
hyp2: tolist t1 = tolist t2
id t1 = id t2
    rewrite id_through_runBatch.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A: Type
t1, t2: T A
hyp1: shape t1 = shape t2
hyp2: tolist t1 = tolist t2
(runBatch id ∘ toBatch) t1 =
(runBatch id ∘ toBatch) t2
    unfold compose.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A: Type
t1, t2: T A
hyp1: shape t1 = shape t2
hyp2: tolist t1 = tolist t2
runBatch id (toBatch t1) = runBatch id (toBatch t2)
    enough (cut: toBatch (A' := A) t1 = toBatch t2)
      by now rewrite cut.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A: Type
t1, t2: T A
hyp1: shape t1 = shape t2
hyp2: tolist t1 = tolist t2
toBatch t1 = toBatch t2
    specialize (same_shape_toBatch (B := A) t1 t2 hyp1).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A: Type
t1, t2: T A
hyp1: shape t1 = shape t2
hyp2: tolist t1 = tolist t2
shape (toBatch t1) = shape (toBatch t2) ->
toBatch t1 = toBatch t2
    specialize (same_tolist_toBatch (B1 := A) (B2 := A) t1 t2 hyp2).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A: Type
t1, t2: T A
hyp1: shape t1 = shape t2
hyp2: tolist t1 = tolist t2
tolist (toBatch t1) = tolist (toBatch t2) ->
shape (toBatch t1) = shape (toBatch t2) ->
toBatch t1 = toBatch t2
    intros.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A: Type
t1, t2: T A
hyp1: shape t1 = shape t2
hyp2: tolist t1 = tolist t2
H2: tolist (toBatch t1) = tolist (toBatch t2)
H3: shape (toBatch t1) = shape (toBatch t2)
toBatch t1 = toBatch t2 apply Batch_shapeliness; assumption.
  Qed.


  Lemma map_tolist_equal_iff: forall `(f1: A -> B) `(f2: A -> B) (t: T A),
      map f1 (tolist t) = map f2 (tolist t) <->
        (forall a: A, a ∈ t -> f1 a = f2 a).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
forall (A B : Type) (f1 f2 : A -> B) (t : T A),
map f1 (tolist t) = map f2 (tolist t) <->
(forall a : A, a ∈ t -> f1 a = f2 a)
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
forall (A B : Type) (f1 f2 : A -> B) (t : T A),
map f1 (tolist t) = map f2 (tolist t) <->
(forall a : A, a ∈ t -> f1 a = f2 a)
    intros.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
map f1 (tolist t) = map f2 (tolist t) <->
(forall a : A, a ∈ t -> f1 a = f2 a)
    setoid_rewrite in_iff_in_tolist.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
map f1 (tolist t) = map f2 (tolist t) <->
(forall a : A, a ∈ tolist t -> f1 a = f2 a)
    induction (tolist t).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
map f1 nil = map f2 nil <->
(forall a : A, a ∈ nil -> f1 a = f2 a)
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
a: A
l: list A
IHl: map f1 l = map f2 l <->
(forall a : A, a ∈ l -> f1 a = f2 a)
map f1 (a :: l) = map f2 (a :: l) <->
(forall a0 : A, a0 ∈ (a :: l) -> f1 a0 = f2 a0)
    -T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
map f1 nil = map f2 nil <->
(forall a : A, a ∈ nil -> f1 a = f2 a) cbn.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
nil = nil <-> (forall a : A, False -> f1 a = f2 a) tauto.
    -T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
a: A
l: list A
IHl: map f1 l = map f2 l <->
(forall a : A, a ∈ l -> f1 a = f2 a)
map f1 (a :: l) = map f2 (a :: l) <->
(forall a0 : A, a0 ∈ (a :: l) -> f1 a0 = f2 a0) cbn.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
a: A
l: list A
IHl: map f1 l = map f2 l <->
(forall a : A, a ∈ l -> f1 a = f2 a)
f1 a :: map f1 l = f2 a :: map f2 l <->
(forall a0 : A,
 a = a0 \/ List.In a0 l -> f1 a0 = f2 a0) split.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
a: A
l: list A
IHl: map f1 l = map f2 l <->
(forall a : A, a ∈ l -> f1 a = f2 a)
f1 a :: map f1 l = f2 a :: map f2 l ->
forall a0 : A, a = a0 \/ List.In a0 l -> f1 a0 = f2 a0
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
a: A
l: list A
IHl: map f1 l = map f2 l <->
(forall a : A, a ∈ l -> f1 a = f2 a)
(forall a0 : A,
 a = a0 \/ List.In a0 l -> f1 a0 = f2 a0) ->
f1 a :: map f1 l = f2 a :: map f2 l
      +T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
a: A
l: list A
IHl: map f1 l = map f2 l <->
(forall a : A, a ∈ l -> f1 a = f2 a)
f1 a :: map f1 l = f2 a :: map f2 l ->
forall a0 : A, a = a0 \/ List.In a0 l -> f1 a0 = f2 a0 introv Hyp.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
a: A
l: list A
IHl: map f1 l = map f2 l <->
(forall a : A, a ∈ l -> f1 a = f2 a)
Hyp: f1 a :: map f1 l = f2 a :: map f2 l
forall a0 : A, a = a0 \/ List.In a0 l -> f1 a0 = f2 a0
        inversion Hyp.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
a: A
l: list A
IHl: map f1 l = map f2 l <->
(forall a : A, a ∈ l -> f1 a = f2 a)
Hyp: f1 a :: map f1 l = f2 a :: map f2 l
H3: f1 a = f2 a
H4: map f1 l = map f2 l
forall a0 : A, a = a0 \/ List.In a0 l -> f1 a0 = f2 a0
        intros a' [Case1 | Case2].T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
a: A
l: list A
IHl: map f1 l = map f2 l <->
(forall a : A, a ∈ l -> f1 a = f2 a)
Hyp: f1 a :: map f1 l = f2 a :: map f2 l
H3: f1 a = f2 a
H4: map f1 l = map f2 l
a': A
Case1: a = a'
f1 a' = f2 a'
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
a: A
l: list A
IHl: map f1 l = map f2 l <->
(forall a : A, a ∈ l -> f1 a = f2 a)
Hyp: f1 a :: map f1 l = f2 a :: map f2 l
H3: f1 a = f2 a
H4: map f1 l = map f2 l
a': A
Case2: List.In a' l
f1 a' = f2 a'
        *T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
a: A
l: list A
IHl: map f1 l = map f2 l <->
(forall a : A, a ∈ l -> f1 a = f2 a)
Hyp: f1 a :: map f1 l = f2 a :: map f2 l
H3: f1 a = f2 a
H4: map f1 l = map f2 l
a': A
Case1: a = a'
f1 a' = f2 a' subst.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
l: list A
IHl: map f1 l = map f2 l <->
(forall a : A, a ∈ l -> f1 a = f2 a)
a': A
H3: f1 a' = f2 a'
Hyp: f1 a' :: map f1 l = f2 a' :: map f2 l
H4: map f1 l = map f2 l
f1 a' = f2 a' assumption.
        *T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
a: A
l: list A
IHl: map f1 l = map f2 l <->
(forall a : A, a ∈ l -> f1 a = f2 a)
Hyp: f1 a :: map f1 l = f2 a :: map f2 l
H3: f1 a = f2 a
H4: map f1 l = map f2 l
a': A
Case2: List.In a' l
f1 a' = f2 a' apply IHl.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
a: A
l: list A
IHl: map f1 l = map f2 l <->
(forall a : A, a ∈ l -> f1 a = f2 a)
Hyp: f1 a :: map f1 l = f2 a :: map f2 l
H3: f1 a = f2 a
H4: map f1 l = map f2 l
a': A
Case2: List.In a' l
map f1 l = map f2 l
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
a: A
l: list A
IHl: map f1 l = map f2 l <->
(forall a : A, a ∈ l -> f1 a = f2 a)
Hyp: f1 a :: map f1 l = f2 a :: map f2 l
H3: f1 a = f2 a
H4: map f1 l = map f2 l
a': A
Case2: List.In a' l
a' ∈ l
          assumption.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
a: A
l: list A
IHl: map f1 l = map f2 l <->
(forall a : A, a ∈ l -> f1 a = f2 a)
Hyp: f1 a :: map f1 l = f2 a :: map f2 l
H3: f1 a = f2 a
H4: map f1 l = map f2 l
a': A
Case2: List.In a' l
a' ∈ l
          assumption.
      +T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
a: A
l: list A
IHl: map f1 l = map f2 l <->
(forall a : A, a ∈ l -> f1 a = f2 a)
(forall a0 : A,
 a = a0 \/ List.In a0 l -> f1 a0 = f2 a0) ->
f1 a :: map f1 l = f2 a :: map f2 l intros X.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
a: A
l: list A
IHl: map f1 l = map f2 l <->
(forall a : A, a ∈ l -> f1 a = f2 a)
X: forall a0 : A,
a = a0 \/ List.In a0 l -> f1 a0 = f2 a0
f1 a :: map f1 l = f2 a :: map f2 l
        assert (cut: f1 a = f2 a).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
a: A
l: list A
IHl: map f1 l = map f2 l <->
(forall a : A, a ∈ l -> f1 a = f2 a)
X: forall a0 : A,
a = a0 \/ List.In a0 l -> f1 a0 = f2 a0
f1 a = f2 a
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
a: A
l: list A
IHl: map f1 l = map f2 l <->
(forall a : A, a ∈ l -> f1 a = f2 a)
X: forall a0 : A,
a = a0 \/ List.In a0 l -> f1 a0 = f2 a0
cut: f1 a = f2 a
f1 a :: map f1 l = f2 a :: map f2 l
        {T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
a: A
l: list A
IHl: map f1 l = map f2 l <->
(forall a : A, a ∈ l -> f1 a = f2 a)
X: forall a0 : A,
a = a0 \/ List.In a0 l -> f1 a0 = f2 a0
f1 a = f2 a apply X.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
a: A
l: list A
IHl: map f1 l = map f2 l <->
(forall a : A, a ∈ l -> f1 a = f2 a)
X: forall a0 : A,
a = a0 \/ List.In a0 l -> f1 a0 = f2 a0
a = a \/ List.In a l now left. }T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
a: A
l: list A
IHl: map f1 l = map f2 l <->
(forall a : A, a ∈ l -> f1 a = f2 a)
X: forall a0 : A,
a = a0 \/ List.In a0 l -> f1 a0 = f2 a0
cut: f1 a = f2 a
f1 a :: map f1 l = f2 a :: map f2 l
        {T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
a: A
l: list A
IHl: map f1 l = map f2 l <->
(forall a : A, a ∈ l -> f1 a = f2 a)
X: forall a0 : A,
a = a0 \/ List.In a0 l -> f1 a0 = f2 a0
cut: f1 a = f2 a
f1 a :: map f1 l = f2 a :: map f2 l rewrite cut.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
a: A
l: list A
IHl: map f1 l = map f2 l <->
(forall a : A, a ∈ l -> f1 a = f2 a)
X: forall a0 : A,
a = a0 \/ List.In a0 l -> f1 a0 = f2 a0
cut: f1 a = f2 a
f2 a :: map f1 l = f2 a :: map f2 l
          fequal.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
a: A
l: list A
IHl: map f1 l = map f2 l <->
(forall a : A, a ∈ l -> f1 a = f2 a)
X: forall a0 : A,
a = a0 \/ List.In a0 l -> f1 a0 = f2 a0
cut: f1 a = f2 a
map f1 l = map f2 l apply IHl.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
a: A
l: list A
IHl: map f1 l = map f2 l <->
(forall a : A, a ∈ l -> f1 a = f2 a)
X: forall a0 : A,
a = a0 \/ List.In a0 l -> f1 a0 = f2 a0
cut: f1 a = f2 a
forall a : A, a ∈ l -> f1 a = f2 a
          firstorder. }
  Qed.

  Lemma map_equal_iff `{! Functor T}: forall `(f1: A -> B) `(f2: A -> B) (t: T A),
      map f1 t = map f2 t <-> map f1 (tolist t) = map f2 (tolist t).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Functor1: Functor T
forall (A B : Type) (f1 f2 : A -> B) (t : T A),
map f1 t = map f2 t <->
map f1 (tolist t) = map f2 (tolist t)
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Functor1: Functor T
forall (A B : Type) (f1 f2 : A -> B) (t : T A),
map f1 t = map f2 t <->
map f1 (tolist t) = map f2 (tolist t)
    intros.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Functor1: Functor T
A, B: Type
f1, f2: A -> B
t: T A
map f1 t = map f2 t <->
map f1 (tolist t) = map f2 (tolist t)
    compose near t on right.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Functor1: Functor T
A, B: Type
f1, f2: A -> B
t: T A
map f1 t = map f2 t <->
(map f1 ∘ tolist) t = (map f2 ∘ tolist) t split.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Functor1: Functor T
A, B: Type
f1, f2: A -> B
t: T A
map f1 t = map f2 t ->
(map f1 ∘ tolist) t = (map f2 ∘ tolist) t
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Functor1: Functor T
A, B: Type
f1, f2: A -> B
t: T A
(map f1 ∘ tolist) t = (map f2 ∘ tolist) t ->
map f1 t = map f2 t
    -T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Functor1: Functor T
A, B: Type
f1, f2: A -> B
t: T A
map f1 t = map f2 t ->
(map f1 ∘ tolist) t = (map f2 ∘ tolist) t introv Hmapeq.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Functor1: Functor T
A, B: Type
f1, f2: A -> B
t: T A
Hmapeq: map f1 t = map f2 t
(map f1 ∘ tolist) t = (map f2 ∘ tolist) t
      rewrite (natural (ϕ := @tolist T _)).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Functor1: Functor T
A, B: Type
f1, f2: A -> B
t: T A
Hmapeq: map f1 t = map f2 t
(tolist ∘ map f1) t = (map f2 ∘ tolist) t
      rewrite (natural (ϕ := @tolist T _)).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Functor1: Functor T
A, B: Type
f1, f2: A -> B
t: T A
Hmapeq: map f1 t = map f2 t
(tolist ∘ map f1) t = (tolist ∘ map f2) t
      unfold compose.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Functor1: Functor T
A, B: Type
f1, f2: A -> B
t: T A
Hmapeq: map f1 t = map f2 t
tolist (map f1 t) = tolist (map f2 t)
      rewrite Hmapeq.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Functor1: Functor T
A, B: Type
f1, f2: A -> B
t: T A
Hmapeq: map f1 t = map f2 t
tolist (map f2 t) = tolist (map f2 t)
      reflexivity.
    -T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Functor1: Functor T
A, B: Type
f1, f2: A -> B
t: T A
(map f1 ∘ tolist) t = (map f2 ∘ tolist) t ->
map f1 t = map f2 t introv Hyp.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Functor1: Functor T
A, B: Type
f1, f2: A -> B
t: T A
Hyp: (map f1 ∘ tolist) t = (map f2 ∘ tolist) t
map f1 t = map f2 t
      specialize (Traversable_shapeliness _ (map f1 t) (map f2 t)).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Functor1: Functor T
A, B: Type
f1, f2: A -> B
t: T A
Hyp: (map f1 ∘ tolist) t = (map f2 ∘ tolist) t
(shape (map f1 t) = shape (map f2 t) /\
 tolist (map f1 t) = tolist (map f2 t) ->
 map f1 t = map f2 t) -> map f1 t = map f2 t
      intros X.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Functor1: Functor T
A, B: Type
f1, f2: A -> B
t: T A
Hyp: (map f1 ∘ tolist) t = (map f2 ∘ tolist) t
X: shape (map f1 t) = shape (map f2 t) /\
tolist (map f1 t) = tolist (map f2 t) ->
map f1 t = map f2 t
map f1 t = map f2 t apply X.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Functor1: Functor T
A, B: Type
f1, f2: A -> B
t: T A
Hyp: (map f1 ∘ tolist) t = (map f2 ∘ tolist) t
X: shape (map f1 t) = shape (map f2 t) /\
tolist (map f1 t) = tolist (map f2 t) ->
map f1 t = map f2 t
shape (map f1 t) = shape (map f2 t) /\
tolist (map f1 t) = tolist (map f2 t) split.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Functor1: Functor T
A, B: Type
f1, f2: A -> B
t: T A
Hyp: (map f1 ∘ tolist) t = (map f2 ∘ tolist) t
X: shape (map f1 t) = shape (map f2 t) /\
tolist (map f1 t) = tolist (map f2 t) ->
map f1 t = map f2 t
shape (map f1 t) = shape (map f2 t)
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Functor1: Functor T
A, B: Type
f1, f2: A -> B
t: T A
Hyp: (map f1 ∘ tolist) t = (map f2 ∘ tolist) t
X: shape (map f1 t) = shape (map f2 t) /\
tolist (map f1 t) = tolist (map f2 t) ->
map f1 t = map f2 t
tolist (map f1 t) = tolist (map f2 t)
      +T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Functor1: Functor T
A, B: Type
f1, f2: A -> B
t: T A
Hyp: (map f1 ∘ tolist) t = (map f2 ∘ tolist) t
X: shape (map f1 t) = shape (map f2 t) /\
tolist (map f1 t) = tolist (map f2 t) ->
map f1 t = map f2 t
shape (map f1 t) = shape (map f2 t) rewrite shape_map.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Functor1: Functor T
A, B: Type
f1, f2: A -> B
t: T A
Hyp: (map f1 ∘ tolist) t = (map f2 ∘ tolist) t
X: shape (map f1 t) = shape (map f2 t) /\
tolist (map f1 t) = tolist (map f2 t) ->
map f1 t = map f2 t
shape t = shape (map f2 t)
        rewrite shape_map.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Functor1: Functor T
A, B: Type
f1, f2: A -> B
t: T A
Hyp: (map f1 ∘ tolist) t = (map f2 ∘ tolist) t
X: shape (map f1 t) = shape (map f2 t) /\
tolist (map f1 t) = tolist (map f2 t) ->
map f1 t = map f2 t
shape t = shape t
        reflexivity.
      +T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Functor1: Functor T
A, B: Type
f1, f2: A -> B
t: T A
Hyp: (map f1 ∘ tolist) t = (map f2 ∘ tolist) t
X: shape (map f1 t) = shape (map f2 t) /\
tolist (map f1 t) = tolist (map f2 t) ->
map f1 t = map f2 t
tolist (map f1 t) = tolist (map f2 t) compose near t.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Functor1: Functor T
A, B: Type
f1, f2: A -> B
t: T A
Hyp: (map f1 ∘ tolist) t = (map f2 ∘ tolist) t
X: shape (map f1 t) = shape (map f2 t) /\
tolist (map f1 t) = tolist (map f2 t) ->
map f1 t = map f2 t
(tolist ∘ map f1) t = (tolist ∘ map f2) t
        rewrite <- (natural (ϕ := @tolist T _)).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Functor1: Functor T
A, B: Type
f1, f2: A -> B
t: T A
Hyp: (map f1 ∘ tolist) t = (map f2 ∘ tolist) t
X: shape (map f1 t) = shape (map f2 t) /\
tolist (map f1 t) = tolist (map f2 t) ->
map f1 t = map f2 t
(map f1 ∘ tolist) t = (tolist ∘ map f2) t
        rewrite <- (natural (ϕ := @tolist T _)).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Functor1: Functor T
A, B: Type
f1, f2: A -> B
t: T A
Hyp: (map f1 ∘ tolist) t = (map f2 ∘ tolist) t
X: shape (map f1 t) = shape (map f2 t) /\
tolist (map f1 t) = tolist (map f2 t) ->
map f1 t = map f2 t
(map f1 ∘ tolist) t = (map f2 ∘ tolist) t
        assumption.
  Qed.

  Lemma map_respectful_iff `{! Functor T}: forall `(f1: A -> B) `(f2: A -> B) (t: T A),
        (forall a: A, a ∈ t -> f1 a = f2 a) <-> map f1 t = map f2 t.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Functor1: Functor T
forall (A B : Type) (f1 f2 : A -> B) (t : T A),
(forall a : A, a ∈ t -> f1 a = f2 a) <->
map f1 t = map f2 t
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Functor1: Functor T
forall (A B : Type) (f1 f2 : A -> B) (t : T A),
(forall a : A, a ∈ t -> f1 a = f2 a) <->
map f1 t = map f2 t
    intros.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Functor1: Functor T
A, B: Type
f1, f2: A -> B
t: T A
(forall a : A, a ∈ t -> f1 a = f2 a) <->
map f1 t = map f2 t
    rewrite map_equal_iff.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Functor1: Functor T
A, B: Type
f1, f2: A -> B
t: T A
(forall a : A, a ∈ t -> f1 a = f2 a) <->
map f1 (tolist t) = map f2 (tolist t)
    rewrite map_tolist_equal_iff.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
H0: Map T
H1: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ToSubset0: ToSubset T
Functor0: Functor T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Functor1: Functor T
A, B: Type
f1, f2: A -> B
t: T A
(forall a : A, a ∈ t -> f1 a = f2 a) <->
(forall a : A, a ∈ t -> f1 a = f2 a)
    tauto.
  Qed.

End shapeliness.

(** ** Pointwise Reasoning *)
(**********************************************************************)
Section pointwise.

  Context
    `{Classes.Kleisli.TraversableFunctor.TraversableFunctor T}
    `{ToMap_inst: Map T}
    `{ToSubset_inst: ToSubset T}
    `{ToBatch_inst: ToBatch T}
    `{! Compat_Map_Traverse T}
    `{! Compat_ToSubset_Traverse T}
    `{! Compat_ToBatch_Traverse T}.

  Lemma traverse_respectful:
    forall `{Applicative G} `(f1: A -> G B) `(f2: A -> G B) (t: T A),
      (forall (a: A), a ∈ t -> f1 a = f2 a) -> traverse f1 t = traverse f2 t.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (G : Type -> Type) (Map_G : Map G)
  (Pure_G : Pure G) (Mult_G : Mult G),
Applicative G ->
forall (A B : Type) (f1 f2 : A -> G B) (t : T A),
(forall a : A, a ∈ t -> f1 a = f2 a) ->
traverse f1 t = traverse f2 t
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (G : Type -> Type) (Map_G : Map G)
  (Pure_G : Pure G) (Mult_G : Mult G),
Applicative G ->
forall (A B : Type) (f1 f2 : A -> G B) (t : T A),
(forall a : A, a ∈ t -> f1 a = f2 a) ->
traverse f1 t = traverse f2 t
    introv ? hyp.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B: Type
f1, f2: A -> G B
t: T A
hyp: forall a : A, a ∈ t -> f1 a = f2 a
traverse f1 t = traverse f2 t
    do 2 rewrite traverse_through_runBatch.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B: Type
f1, f2: A -> G B
t: T A
hyp: forall a : A, a ∈ t -> f1 a = f2 a
(runBatch f1 ∘ toBatch) t = (runBatch f2 ∘ toBatch) t
    unfold element_of in hyp.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B: Type
f1, f2: A -> G B
t: T A
hyp: forall a : A, tosubset t a -> f1 a = f2 a
(runBatch f1 ∘ toBatch) t = (runBatch f2 ∘ toBatch) t
    rewrite (tosubset_through_runBatch2 A B) in hyp.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B: Type
f1, f2: A -> G B
t: T A
hyp: forall a : A,
(runBatch ret ∘ toBatch) t a -> f1 a = f2 a
(runBatch f1 ∘ toBatch) t = (runBatch f2 ∘ toBatch) t
    unfold compose in *.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B: Type
f1, f2: A -> G B
t: T A
hyp: forall a : A,
runBatch ret (toBatch t) a -> f1 a = f2 a
runBatch f1 (toBatch t) = runBatch f2 (toBatch t)
    unfold ret in *.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B: Type
f1, f2: A -> G B
t: T A
hyp: forall a : A,
runBatch (Return_subset A) (toBatch t) a ->
f1 a = f2 a
runBatch f1 (toBatch t) = runBatch f2 (toBatch t)
    induction (toBatch t).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B: Type
f1, f2: A -> G B
t: T A
C: Type
c: C
hyp: forall a : A,
runBatch (Return_subset A) (Done c) a ->
f1 a = f2 a
runBatch f1 (Done c) = runBatch f2 (Done c)
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B: Type
f1, f2: A -> G B
t: T A
C: Type
b: Batch A B (B -> C)
a: A
hyp: forall a0 : A,
runBatch (Return_subset A) (b ⧆ a) a0 ->
f1 a0 = f2 a0
IHb: (forall a : A,
 runBatch (Return_subset A) b a -> f1 a = f2 a) ->
runBatch f1 b = runBatch f2 b
runBatch f1 (b ⧆ a) = runBatch f2 (b ⧆ a)
    -T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B: Type
f1, f2: A -> G B
t: T A
C: Type
c: C
hyp: forall a : A,
runBatch (Return_subset A) (Done c) a ->
f1 a = f2 a
runBatch f1 (Done c) = runBatch f2 (Done c) reflexivity.
    -T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B: Type
f1, f2: A -> G B
t: T A
C: Type
b: Batch A B (B -> C)
a: A
hyp: forall a0 : A,
runBatch (Return_subset A) (b ⧆ a) a0 ->
f1 a0 = f2 a0
IHb: (forall a : A,
 runBatch (Return_subset A) b a -> f1 a = f2 a) ->
runBatch f1 b = runBatch f2 b
runBatch f1 (b ⧆ a) = runBatch f2 (b ⧆ a) cbn.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B: Type
f1, f2: A -> G B
t: T A
C: Type
b: Batch A B (B -> C)
a: A
hyp: forall a0 : A,
runBatch (Return_subset A) (b ⧆ a) a0 ->
f1 a0 = f2 a0
IHb: (forall a : A,
 runBatch (Return_subset A) b a -> f1 a = f2 a) ->
runBatch f1 b = runBatch f2 b
runBatch f1 b <⋆> f1 a = runBatch f2 b <⋆> f2 a fequal.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B: Type
f1, f2: A -> G B
t: T A
C: Type
b: Batch A B (B -> C)
a: A
hyp: forall a0 : A,
runBatch (Return_subset A) (b ⧆ a) a0 ->
f1 a0 = f2 a0
IHb: (forall a : A,
 runBatch (Return_subset A) b a -> f1 a = f2 a) ->
runBatch f1 b = runBatch f2 b
runBatch f1 b = runBatch f2 b
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B: Type
f1, f2: A -> G B
t: T A
C: Type
b: Batch A B (B -> C)
a: A
hyp: forall a0 : A,
runBatch (Return_subset A) (b ⧆ a) a0 ->
f1 a0 = f2 a0
IHb: (forall a : A,
 runBatch (Return_subset A) b a -> f1 a = f2 a) ->
runBatch f1 b = runBatch f2 b
f1 a = f2 a
      +T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B: Type
f1, f2: A -> G B
t: T A
C: Type
b: Batch A B (B -> C)
a: A
hyp: forall a0 : A,
runBatch (Return_subset A) (b ⧆ a) a0 ->
f1 a0 = f2 a0
IHb: (forall a : A,
 runBatch (Return_subset A) b a -> f1 a = f2 a) ->
runBatch f1 b = runBatch f2 b
runBatch f1 b = runBatch f2 b apply IHb.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B: Type
f1, f2: A -> G B
t: T A
C: Type
b: Batch A B (B -> C)
a: A
hyp: forall a0 : A,
runBatch (Return_subset A) (b ⧆ a) a0 ->
f1 a0 = f2 a0
IHb: (forall a : A,
 runBatch (Return_subset A) b a -> f1 a = f2 a) ->
runBatch f1 b = runBatch f2 b
forall a : A,
runBatch (Return_subset A) b a -> f1 a = f2 a intros.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B: Type
f1, f2: A -> G B
t: T A
C: Type
b: Batch A B (B -> C)
a: A
hyp: forall a0 : A,
runBatch (Return_subset A) (b ⧆ a) a0 ->
f1 a0 = f2 a0
IHb: (forall a : A,
 runBatch (Return_subset A) b a -> f1 a = f2 a) ->
runBatch f1 b = runBatch f2 b
a0: A
H1: runBatch (Return_subset A) b a0
f1 a0 = f2 a0
        apply hyp.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B: Type
f1, f2: A -> G B
t: T A
C: Type
b: Batch A B (B -> C)
a: A
hyp: forall a0 : A,
runBatch (Return_subset A) (b ⧆ a) a0 ->
f1 a0 = f2 a0
IHb: (forall a : A,
 runBatch (Return_subset A) b a -> f1 a = f2 a) ->
runBatch f1 b = runBatch f2 b
a0: A
H1: runBatch (Return_subset A) b a0
runBatch (Return_subset A) (b ⧆ a) a0 now left.
      +T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B: Type
f1, f2: A -> G B
t: T A
C: Type
b: Batch A B (B -> C)
a: A
hyp: forall a0 : A,
runBatch (Return_subset A) (b ⧆ a) a0 ->
f1 a0 = f2 a0
IHb: (forall a : A,
 runBatch (Return_subset A) b a -> f1 a = f2 a) ->
runBatch f1 b = runBatch f2 b
f1 a = f2 a apply hyp.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B: Type
f1, f2: A -> G B
t: T A
C: Type
b: Batch A B (B -> C)
a: A
hyp: forall a0 : A,
runBatch (Return_subset A) (b ⧆ a) a0 ->
f1 a0 = f2 a0
IHb: (forall a : A,
 runBatch (Return_subset A) b a -> f1 a = f2 a) ->
runBatch f1 b = runBatch f2 b
runBatch (Return_subset A) (b ⧆ a) a now right.
  Qed.

  (** *** Corollaries *)
  (********************************************************************)
  Corollary traverse_respectful_pure:
    forall `{Applicative G} `(f1: A -> G A) (t: T A),
      (forall (a: A), a ∈ t -> f1 a = pure a) -> traverse f1 t = pure t.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (G : Type -> Type) (Map_G : Map G)
  (Pure_G : Pure G) (Mult_G : Mult G),
Applicative G ->
forall (A : Type) (f1 : A -> G A) (t : T A),
(forall a : A, a ∈ t -> f1 a = pure a) ->
traverse f1 t = pure t
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (G : Type -> Type) (Map_G : Map G)
  (Pure_G : Pure G) (Mult_G : Mult G),
Applicative G ->
forall (A : Type) (f1 : A -> G A) (t : T A),
(forall a : A, a ∈ t -> f1 a = pure a) ->
traverse f1 t = pure t
    intros.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A: Type
f1: A -> G A
t: T A
H1: forall a : A, a ∈ t -> f1 a = pure a
traverse f1 t = pure t
    rewrite <- traverse_purity1.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A: Type
f1: A -> G A
t: T A
H1: forall a : A, a ∈ t -> f1 a = pure a
traverse f1 t = traverse pure t
    now apply traverse_respectful.
  Qed.

  Corollary traverse_respectful_map {A B}:
    forall `{Applicative G} (t: T A) (f: A -> G B) (g: A -> B),
      (forall a, a ∈ t -> f a = pure (g a)) -> traverse f t = pure (map g t).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
forall (G : Type -> Type) (Map_G : Map G)
  (Pure_G : Pure G) (Mult_G : Mult G),
Applicative G ->
forall (t : T A) (f : A -> G B) (g : A -> B),
(forall a : A, a ∈ t -> f a = pure (g a)) ->
traverse f t = pure (map g t)
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
forall (G : Type -> Type) (Map_G : Map G)
  (Pure_G : Pure G) (Mult_G : Mult G),
Applicative G ->
forall (t : T A) (f : A -> G B) (g : A -> B),
(forall a : A, a ∈ t -> f a = pure (g a)) ->
traverse f t = pure (map g t)
    intros.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
t: T A
f: A -> G B
g: A -> B
H1: forall a : A, a ∈ t -> f a = pure (g a)
traverse f t = pure (map g t) rewrite <- (traverse_purity1 (G := G)).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
t: T A
f: A -> G B
g: A -> B
H1: forall a : A, a ∈ t -> f a = pure (g a)
traverse f t = traverse pure (map g t)
    compose near t on right.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
t: T A
f: A -> G B
g: A -> B
H1: forall a : A, a ∈ t -> f a = pure (g a)
traverse f t = (traverse pure ∘ map g) t
    rewrite traverse_map.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
t: T A
f: A -> G B
g: A -> B
H1: forall a : A, a ∈ t -> f a = pure (g a)
traverse f t = traverse (pure ∘ g) t
    apply traverse_respectful.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
t: T A
f: A -> G B
g: A -> B
H1: forall a : A, a ∈ t -> f a = pure (g a)
forall a : A, a ∈ t -> f a = (pure ∘ g) a
    assumption.
  Qed.

  Corollary traverse_respectful_id {A}:
    forall (t: T A) (f: A -> A),
      (forall a, a ∈ t -> f a = id a) -> traverse (G := fun A => A) f t = t.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
forall (t : T A) (f : A -> A),
(forall a : A, a ∈ t -> f a = id a) ->
traverse f t = t
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
forall (t : T A) (f : A -> A),
(forall a : A, a ∈ t -> f a = id a) ->
traverse f t = t
    intros.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
f: A -> A
H0: forall a : A, a ∈ t -> f a = id a
traverse f t = t
    change t with (pure (F := fun A => A) t) at 2.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
f: A -> A
H0: forall a : A, a ∈ t -> f a = id a
traverse f t = pure t
    apply (traverse_respectful_pure (G := fun A => A)).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
f: A -> A
H0: forall a : A, a ∈ t -> f a = id a
forall a : A, a ∈ t -> f a = pure a
    assumption.
  Qed.

  Corollary map_respectful: forall `(f1: A -> B) `(f2: A -> B) (t: T A),
      (forall (a: A), a ∈ t -> f1 a = f2 a) -> map f1 t = map f2 t.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A B : Type) (f1 f2 : A -> B) (t : T A),
(forall a : A, a ∈ t -> f1 a = f2 a) ->
map f1 t = map f2 t
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A B : Type) (f1 f2 : A -> B) (t : T A),
(forall a : A, a ∈ t -> f1 a = f2 a) ->
map f1 t = map f2 t
    introv hyp.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
hyp: forall a : A, a ∈ t -> f1 a = f2 a
map f1 t = map f2 t
    rewrite map_to_traverse.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
hyp: forall a : A, a ∈ t -> f1 a = f2 a
traverse f1 t = map f2 t
    rewrite map_to_traverse.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
hyp: forall a : A, a ∈ t -> f1 a = f2 a
traverse f1 t = traverse f2 t
    apply (traverse_respectful (G := fun A => A)).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
f1, f2: A -> B
t: T A
hyp: forall a : A, a ∈ t -> f1 a = f2 a
forall a : A, a ∈ t -> f1 a = f2 a
    assumption.
  Qed.

  (** ** Typeclass Instances *)
  (********************************************************************)
  #[export] Instance ContainerFunctor_Traverse:
    ContainerFunctor T.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ContainerFunctor T
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ContainerFunctor T
    constructor.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
Natural (@tosubset T ToSubset_inst)
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
Functor T
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A B : Type) (t : T A) (f g : A -> B),
(forall a : A, a ∈ t -> f a = g a) ->
map f t = map g t
    -T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
Natural (@tosubset T ToSubset_inst) rewrite compat_tosubset_traverse.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
Natural ToSubset_Traverse
      typeclasses eauto.
    -T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
Functor T apply DerivedInstances.Functor_TraversableFunctor.
    -T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A B : Type) (t : T A) (f g : A -> B),
(forall a : A, a ∈ t -> f a = g a) ->
map f t = map g t intros.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
f, g: A -> B
H0: forall a : A, a ∈ t -> f a = g a
map f t = map g t now apply map_respectful.
  Qed.

  #[export] Instance ShapelyFunctor_Traverse:
    ShapelyFunctor T.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ShapelyFunctor T
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
ShapelyFunctor T
    constructor.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
Natural (@tolist T Tolist_Traverse)
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
Functor T
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
shapeliness T
    -T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
Natural (@tolist T Tolist_Traverse) typeclasses eauto.
    -T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
Functor T typeclasses eauto.
    -T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
shapeliness T unfold shapeliness.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A : Type) (t1 t2 : T A),
shape t1 = shape t2 /\ tolist t1 = tolist t2 ->
t1 = t2
      apply Traversable_shapeliness.
  Qed.

End pointwise.

(** * <<plength>> *)
(**********************************************************************)
Section length.

  Context
    `{Map T}
    `{ToBatch T}
    `{Traverse T}
    `{! TraversableFunctor T}
    `{! Compat_Map_Traverse T}
    `{! Compat_ToBatch_Traverse T}.

  Lemma plength_eq_length:
    forall {A} {B} (t: T A),
      length_Batch (toBatch (A' := B) t) = plength t.T: Type -> Type
H: Map T
H0: ToBatch T
H1: Traverse T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A B : Type) (t : T A),
length_Batch (toBatch t) = plength t
  Proof.T: Type -> Type
H: Map T
H0: ToBatch T
H1: Traverse T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A B : Type) (t : T A),
length_Batch (toBatch t) = plength t
    intros.T: Type -> Type
H: Map T
H0: ToBatch T
H1: Traverse T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
length_Batch (toBatch t) = plength t
    unfold plength.T: Type -> Type
H: Map T
H0: ToBatch T
H1: Traverse T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
length_Batch (toBatch t) =
mapReduce (fun _ : A => 1) t
    rewrite (mapReduce_through_runBatch2 A B).T: Type -> Type
H: Map T
H0: ToBatch T
H1: Traverse T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
length_Batch (toBatch t) =
(runBatch (fun _ : A => 1) ∘ toBatch) t
    unfold compose.T: Type -> Type
H: Map T
H0: ToBatch T
H1: Traverse T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
length_Batch (toBatch t) =
runBatch (fun _ : A => 1) (toBatch t)
    induction (toBatch t).T: Type -> Type
H: Map T
H0: ToBatch T
H1: Traverse T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
C: Type
c: C
length_Batch (Done c) =
runBatch (fun _ : A => 1) (Done c)
T: Type -> Type
H: Map T
H0: ToBatch T
H1: Traverse T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
C: Type
b: Batch A B (B -> C)
a: A
IHb: length_Batch b = runBatch (fun _ : A => 1) b
length_Batch (b ⧆ a) =
runBatch (fun _ : A => 1) (b ⧆ a)
    -T: Type -> Type
H: Map T
H0: ToBatch T
H1: Traverse T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
C: Type
c: C
length_Batch (Done c) =
runBatch (fun _ : A => 1) (Done c) reflexivity.
    -T: Type -> Type
H: Map T
H0: ToBatch T
H1: Traverse T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
C: Type
b: Batch A B (B -> C)
a: A
IHb: length_Batch b = runBatch (fun _ : A => 1) b
length_Batch (b ⧆ a) =
runBatch (fun _ : A => 1) (b ⧆ a) cbn.T: Type -> Type
H: Map T
H0: ToBatch T
H1: Traverse T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
C: Type
b: Batch A B (B -> C)
a: A
IHb: length_Batch b = runBatch (fun _ : A => 1) b
S (length_Batch b) = runBatch (fun _ : A => 1) b ● 1
      rewrite IHb.T: Type -> Type
H: Map T
H0: ToBatch T
H1: Traverse T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
C: Type
b: Batch A B (B -> C)
a: A
IHb: length_Batch b = runBatch (fun _ : A => 1) b
S (runBatch (fun _ : A => 1) b) =
runBatch (fun _ : A => 1) b ● 1
      unfold_ops @NaturalNumbers.Monoid_op_plus.T: Type -> Type
H: Map T
H0: ToBatch T
H1: Traverse T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
C: Type
b: Batch A B (B -> C)
a: A
IHb: length_Batch b = runBatch (fun _ : A => 1) b
S (runBatch (fun _ : A => 1) b) =
(runBatch (fun _ : A => 1) b + 1)%nat
      lia.
  Qed.

  Lemma plength_eq_length': forall {A} (t: T A),
      plength t = length_Batch (toBatch (A' := False) t).T: Type -> Type
H: Map T
H0: ToBatch T
H1: Traverse T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A : Type) (t : T A),
plength t = length_Batch (toBatch t)
  Proof.T: Type -> Type
H: Map T
H0: ToBatch T
H1: Traverse T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A : Type) (t : T A),
plength t = length_Batch (toBatch t)
    intros.T: Type -> Type
H: Map T
H0: ToBatch T
H1: Traverse T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
plength t = length_Batch (toBatch t)
    symmetry.T: Type -> Type
H: Map T
H0: ToBatch T
H1: Traverse T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
length_Batch (toBatch t) = plength t
    apply plength_eq_length.
  Qed.

End length.

(** * Factorizing Terms into <<shape>> and <<contents>> *)
(**********************************************************************)
Section deconstruction.

  Definition trav_contents
    {T: Type -> Type} {toBatch_T: ToBatch T} {traverse_T: Traverse T} {map_T: Map T}
    {cmt: Compat_Map_Traverse T}
    {cbt: Compat_ToBatch_Traverse T}
    {Trav_T: TraversableFunctor T}
    {A} (t: T A): Vector (plength t) A :=
    let v: Vector
             (length_Batch (toBatch (ToBatch := toBatch_T) (A' := False) t)) A
      := Batch_contents (toBatch t)
    in coerce_Vector_length (plength_eq_length t) v.

  Definition trav_make
    {T: Type -> Type}
    {map_T: Map T}
    {traverse_T: Traverse T}
    {toBatch_T: ToBatch T}
    {cmt: Compat_Map_Traverse T}
    {cmt: Compat_ToBatch_Traverse T}
    {Trav_T: TraversableFunctor T}
    {A B: Type} (t: T A):
    Vector (plength t) B -> T B :=
    (fun v =>
       let v' := coerce_Vector_length (eq_sym (plength_eq_length t)) v
       in Batch_make (toBatch t) v').

  Context
    `{Traverse T}
    `{Map T}
    `{ToBatch T}
    `{! TraversableFunctor T}
    `{! Compat_Map_Traverse T}
    `{! Compat_ToBatch_Traverse T}.

  #[local] Generalizable Variables v.


  (** ** Operations on Vectors *)
  (********************************************************************)
  Section traverse_vector.

    Lemma trav_contents_Vector {n: nat} {A: Type}:
      forall (v: Vector n A),
        trav_contents v ~~ reverse_Vector v.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A: Type
forall v : Vector n A,
trav_contents v ~~ reverse_Vector v
    Proof.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A: Type
forall v : Vector n A,
trav_contents v ~~ reverse_Vector v
      intros.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A: Type
v: Vector n A
trav_contents v ~~ reverse_Vector v
      unfold Vector_sim.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A: Type
v: Vector n A
proj1_sig (trav_contents v) =
proj1_sig (reverse_Vector v)
      unfold trav_contents.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A: Type
v: Vector n A
proj1_sig
  (coerce plength_eq_length v
   in Batch_contents (toBatch v)) =
proj1_sig (reverse_Vector v)
      rewrite <- coerce_Vector_contents.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A: Type
v: Vector n A
proj1_sig (Batch_contents (toBatch v)) =
proj1_sig (reverse_Vector v)
      induction v using Vector_induction.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A: Type
proj1_sig (Batch_contents (toBatch vnil)) =
proj1_sig (reverse_Vector vnil)
T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A: Type
a: A
m: nat
v: Vector m A
IHv: proj1_sig (Batch_contents (toBatch v)) =
proj1_sig (reverse_Vector v)
proj1_sig (Batch_contents (toBatch (vcons m a v))) =
proj1_sig (reverse_Vector (vcons m a v))
      -T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A: Type
proj1_sig (Batch_contents (toBatch vnil)) =
proj1_sig (reverse_Vector vnil) reflexivity.
      -T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A: Type
a: A
m: nat
v: Vector m A
IHv: proj1_sig (Batch_contents (toBatch v)) =
proj1_sig (reverse_Vector v)
proj1_sig (Batch_contents (toBatch (vcons m a v))) =
proj1_sig (reverse_Vector (vcons m a v)) rewrite toBatch_to_traverse.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A: Type
a: A
m: nat
v: Vector m A
IHv: proj1_sig (Batch_contents (toBatch v)) =
proj1_sig (reverse_Vector v)
proj1_sig
  (Batch_contents
     (traverse (batch A False) (vcons m a v))) =
proj1_sig (reverse_Vector (vcons m a v))
        rewrite traverse_Vector_vcons.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A: Type
a: A
m: nat
v: Vector m A
IHv: proj1_sig (Batch_contents (toBatch v)) =
proj1_sig (reverse_Vector v)
proj1_sig
  (Batch_contents
     (pure (vcons m) <⋆> batch A False a <⋆>
      traverse (batch A False) v)) =
proj1_sig (reverse_Vector (vcons m a v))
        rewrite Batch_contents_rw_app.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A: Type
a: A
m: nat
v: Vector m A
IHv: proj1_sig (Batch_contents (toBatch v)) =
proj1_sig (reverse_Vector v)
proj1_sig
  (Vector_append
     (Batch_contents (traverse (batch A False) v))
     (Batch_contents
        (pure (vcons m) <⋆> batch A False a))) =
proj1_sig (reverse_Vector (vcons m a v))
        rewrite proj_Vector_append.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A: Type
a: A
m: nat
v: Vector m A
IHv: proj1_sig (Batch_contents (toBatch v)) =
proj1_sig (reverse_Vector v)
proj1_sig
  (Batch_contents (traverse (batch A False) v)) ++
proj1_sig
  (Batch_contents (pure (vcons m) <⋆> batch A False a)) =
proj1_sig (reverse_Vector (vcons m a v))
        rewrite Batch_contents_rw_app.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A: Type
a: A
m: nat
v: Vector m A
IHv: proj1_sig (Batch_contents (toBatch v)) =
proj1_sig (reverse_Vector v)
proj1_sig
  (Batch_contents (traverse (batch A False) v)) ++
proj1_sig
  (Vector_append (Batch_contents (batch A False a))
     (Batch_contents (pure (vcons m)))) =
proj1_sig (reverse_Vector (vcons m a v))
        rewrite proj_Vector_append.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A: Type
a: A
m: nat
v: Vector m A
IHv: proj1_sig (Batch_contents (toBatch v)) =
proj1_sig (reverse_Vector v)
proj1_sig
  (Batch_contents (traverse (batch A False) v)) ++
proj1_sig (Batch_contents (batch A False a)) ++
proj1_sig (Batch_contents (pure (vcons m))) =
proj1_sig (reverse_Vector (vcons m a v))
        rewrite Batch_contents_rw_pure.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A: Type
a: A
m: nat
v: Vector m A
IHv: proj1_sig (Batch_contents (toBatch v)) =
proj1_sig (reverse_Vector v)
proj1_sig
  (Batch_contents (traverse (batch A False) v)) ++
proj1_sig (Batch_contents (batch A False a)) ++
proj1_sig vnil =
proj1_sig (reverse_Vector (vcons m a v))
        rewrite proj_reverse_Vector.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A: Type
a: A
m: nat
v: Vector m A
IHv: proj1_sig (Batch_contents (toBatch v)) =
proj1_sig (reverse_Vector v)
proj1_sig
  (Batch_contents (traverse (batch A False) v)) ++
proj1_sig (Batch_contents (batch A False a)) ++
proj1_sig vnil = List.rev (proj1_sig (vcons m a v))
        rewrite proj_vcons.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A: Type
a: A
m: nat
v: Vector m A
IHv: proj1_sig (Batch_contents (toBatch v)) =
proj1_sig (reverse_Vector v)
proj1_sig
  (Batch_contents (traverse (batch A False) v)) ++
proj1_sig (Batch_contents (batch A False a)) ++
proj1_sig vnil = List.rev (a :: proj1_sig v)
        cbn.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A: Type
a: A
m: nat
v: Vector m A
IHv: proj1_sig (Batch_contents (toBatch v)) =
proj1_sig (reverse_Vector v)
proj1_sig
  (Batch_contents (traverse (batch A False) v)) ++
a :: nil = List.rev (proj1_sig v) ++ a :: nil
        rewrite <- proj_reverse_Vector.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A: Type
a: A
m: nat
v: Vector m A
IHv: proj1_sig (Batch_contents (toBatch v)) =
proj1_sig (reverse_Vector v)
proj1_sig
  (Batch_contents (traverse (batch A False) v)) ++
a :: nil = proj1_sig (reverse_Vector v) ++ a :: nil
        rewrite <- IHv.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A: Type
a: A
m: nat
v: Vector m A
IHv: proj1_sig (Batch_contents (toBatch v)) =
proj1_sig (reverse_Vector v)
proj1_sig
  (Batch_contents (traverse (batch A False) v)) ++
a :: nil =
proj1_sig (Batch_contents (toBatch v)) ++ a :: nil
        reflexivity.
    Qed.

    Lemma trav_make_Vector {n: nat} {A B: Type}:
      forall (v1: Vector n A) (v2: Vector (plength v1) B),
        (trav_make (B := B) v1 v2) ~~ v2.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B: Type
forall (v1 : Vector n A) (v2 : Vector (plength v1) B),
trav_make v1 v2 ~~ v2
    Proof.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B: Type
forall (v1 : Vector n A) (v2 : Vector (plength v1) B),
trav_make v1 v2 ~~ v2
      intros.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B: Type
v1: Vector n A
v2: Vector (plength v1) B
trav_make v1 v2 ~~ v2
      induction v1 using Vector_induction.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B: Type
v2: Vector (plength vnil) B
trav_make vnil v2 ~~ v2
T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B: Type
a: A
m: nat
v1: Vector m A
v2: Vector (plength (vcons m a v1)) B
IHv1: forall v2 : Vector (plength v1) B,
trav_make v1 v2 ~~ v2
trav_make (vcons m a v1) v2 ~~ v2
      -T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B: Type
v2: Vector (plength vnil) B
trav_make vnil v2 ~~ v2 assert (Hey: v2 = vnil).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B: Type
v2: Vector (plength vnil) B
v2 = vnil
T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B: Type
v2: Vector (plength vnil) B
Hey: v2 = vnil
trav_make vnil v2 ~~ v2
        {T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B: Type
v2: Vector (plength vnil) B
v2 = vnil apply Vector_nil_eq. }T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B: Type
v2: Vector (plength vnil) B
Hey: v2 = vnil
trav_make vnil v2 ~~ v2
        rewrite Hey.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B: Type
v2: Vector (plength vnil) B
Hey: v2 = vnil
trav_make vnil vnil ~~ vnil
        reflexivity.
      -T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B: Type
a: A
m: nat
v1: Vector m A
v2: Vector (plength (vcons m a v1)) B
IHv1: forall v2 : Vector (plength v1) B,
trav_make v1 v2 ~~ v2
trav_make (vcons m a v1) v2 ~~ v2 cbn in v2.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B: Type
a: A
m: nat
v1: Vector m A
v2: Vector (plength (vcons m a v1)) B
IHv1: forall v2 : Vector (plength v1) B,
trav_make v1 v2 ~~ v2
trav_make (vcons m a v1) v2 ~~ v2
        unfold trav_make.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B: Type
a: A
m: nat
v1: Vector m A
v2: Vector (plength (vcons m a v1)) B
IHv1: forall v2 : Vector (plength v1) B,
trav_make v1 v2 ~~ v2
Batch_make (toBatch (vcons m a v1))
  (coerce eq_sym (plength_eq_length (vcons m a v1))
   in v2) ~~ v2
        pose (toBatch_to_traverse (T := Vector (S m)) A B).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B: Type
a: A
m: nat
v1: Vector m A
v2: Vector (plength (vcons m a v1)) B
IHv1: forall v2 : Vector (plength v1) B,
trav_make v1 v2 ~~ v2
e:= toBatch_to_traverse A B: toBatch = traverse (batch A B)
Batch_make (toBatch (vcons m a v1))
  (coerce eq_sym (plength_eq_length (vcons m a v1))
   in v2) ~~ v2
    Abort.

  End traverse_vector.

  (** ** Lemmas regarding <<trav_make>> *)
  (********************************************************************)
  Section trav_make_lemmas.

    Context
      {A B: Type}.

    Lemma trav_make_sim_refl:
      forall (t: T A), trav_make (B := B) t ~!~ trav_make t.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
forall t : T A, trav_make t ~!~ trav_make t
    Proof.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
forall t : T A, trav_make t ~!~ trav_make t
      intros.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
trav_make t ~!~ trav_make t
      unfold trav_make.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
(Batch_make (toBatch t)
 ○ coerce_Vector_length (eq_sym (plength_eq_length t))) ~!~
(Batch_make (toBatch t)
 ○ coerce_Vector_length (eq_sym (plength_eq_length t)))
      unfold Vector_fun_sim.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
plength t = plength t /\
(forall v1 v2 : Vector (plength t) B,
 v1 ~~ v2 ->
 Batch_make (toBatch t)
   (coerce eq_sym (plength_eq_length t) in v1) =
 Batch_make (toBatch t)
   (coerce eq_sym (plength_eq_length t) in v2)) split.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
plength t = plength t
T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
forall v1 v2 : Vector (plength t) B,
v1 ~~ v2 ->
Batch_make (toBatch t)
  (coerce eq_sym (plength_eq_length t) in v1) =
Batch_make (toBatch t)
  (coerce eq_sym (plength_eq_length t) in v2)
      -T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
plength t = plength t reflexivity.
      -T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
forall v1 v2 : Vector (plength t) B,
v1 ~~ v2 ->
Batch_make (toBatch t)
  (coerce eq_sym (plength_eq_length t) in v1) =
Batch_make (toBatch t)
  (coerce eq_sym (plength_eq_length t) in v2) intros.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
v1, v2: Vector (plength t) B
H2: v1 ~~ v2
Batch_make (toBatch t)
  (coerce eq_sym (plength_eq_length t) in v1) =
Batch_make (toBatch t)
  (coerce eq_sym (plength_eq_length t) in v2)
        apply Batch_make_sim1.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
v1, v2: Vector (plength t) B
H2: v1 ~~ v2
coerce eq_sym (plength_eq_length t) in v1 ~~
coerce eq_sym (plength_eq_length t) in v2
        apply Vector_coerce_sim_l'.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
v1, v2: Vector (plength t) B
H2: v1 ~~ v2
v1 ~~ coerce eq_sym (plength_eq_length t) in v2
        apply Vector_coerce_sim_r'.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
v1, v2: Vector (plength t) B
H2: v1 ~~ v2
v1 ~~ v2
        assumption.
    Qed.

    Lemma toBatch_trav_make_to_replace_contents
      {A'} {t: T A} {v: Vector (plength t) B}:
      toBatch (A' := A') (trav_make t v) =
        Batch_replace_contents (toBatch (A' := A') t)
          (coerce eq_sym (plength_eq_length t) in v).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A': Type
t: T A
v: Vector (plength t) B
toBatch (trav_make t v) =
Batch_replace_contents (toBatch t)
  (coerce eq_sym (plength_eq_length t) in v)
    Proof.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A': Type
t: T A
v: Vector (plength t) B
toBatch (trav_make t v) =
Batch_replace_contents (toBatch t)
  (coerce eq_sym (plength_eq_length t) in v)
      unfold trav_make.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A': Type
t: T A
v: Vector (plength t) B
toBatch
  (Batch_make (toBatch t)
     (coerce eq_sym (plength_eq_length t) in v)) =
Batch_replace_contents (toBatch t)
  (coerce eq_sym (plength_eq_length t) in v)
      rewrite Batch_make_natural_rw1.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A': Type
t: T A
v: Vector (plength t) B
Batch_make (map toBatch (toBatch t))
  (coerce batch_length_map toBatch (toBatch t)
   in coerce eq_sym (plength_eq_length t) in v) =
Batch_replace_contents (toBatch t)
  (coerce eq_sym (plength_eq_length t) in v)
      rewrite Batch_replace_contents_spec.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A': Type
t: T A
v: Vector (plength t) B
Batch_make (map toBatch (toBatch t))
  (coerce batch_length_map toBatch (toBatch t)
   in coerce eq_sym (plength_eq_length t) in v) =
Batch_make (cojoin_Batch (toBatch t))
  (coerce length_cojoin_Batch (toBatch t)
   in coerce eq_sym (plength_eq_length t) in v)
      apply Batch_make_sim2.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A': Type
t: T A
v: Vector (plength t) B
map toBatch (toBatch t) = cojoin_Batch (toBatch t)
T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A': Type
t: T A
v: Vector (plength t) B
coerce batch_length_map toBatch (toBatch t)
in coerce eq_sym (plength_eq_length t) in v ~~
coerce length_cojoin_Batch (toBatch t)
in coerce eq_sym (plength_eq_length t) in v
      -T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A': Type
t: T A
v: Vector (plength t) B
map toBatch (toBatch t) = cojoin_Batch (toBatch t) compose near t.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A': Type
t: T A
v: Vector (plength t) B
(map toBatch ∘ toBatch) t = (cojoin_Batch ∘ toBatch) t
        rewrite (TraversableFunctor.trf_duplicate (T := T)).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A': Type
t: T A
v: Vector (plength t) B
(map toBatch ∘ toBatch) t = (map toBatch ∘ toBatch) t
        rewrite compat_toBatch_traverse.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A': Type
t: T A
v: Vector (plength t) B
(map (DerivedOperations.ToBatch_Traverse B A')
 ∘ DerivedOperations.ToBatch_Traverse A B) t =
(map (DerivedOperations.ToBatch_Traverse B A')
 ∘ DerivedOperations.ToBatch_Traverse A B) t
        reflexivity.
      -T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A': Type
t: T A
v: Vector (plength t) B
coerce batch_length_map toBatch (toBatch t)
in coerce eq_sym (plength_eq_length t) in v ~~
coerce length_cojoin_Batch (toBatch t)
in coerce eq_sym (plength_eq_length t) in v vector_sim.
    Qed.

    (** ** Naturality of <<trav_contents>> and <<trav_make>> *)
    (******************************************************************)
    Lemma trav_contents_natural:
      forall (A B: Type) (t: T A) (f: A -> B),
        trav_contents (map f t) ~~ map f (trav_contents t).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
forall (A B : Type) (t : T A) (f : A -> B),
trav_contents (map f t) ~~ map f (trav_contents t)
    Proof.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
forall (A B : Type) (t : T A) (f : A -> B),
trav_contents (map f t) ~~ map f (trav_contents t)
      intros.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A0, B0: Type
t: T A0
f: A0 -> B0
trav_contents (map f t) ~~ map f (trav_contents t)
      unfold Vector_sim.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A0, B0: Type
t: T A0
f: A0 -> B0
proj1_sig (trav_contents (map f t)) =
proj1_sig (map f (trav_contents t))
      unfold trav_contents.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A0, B0: Type
t: T A0
f: A0 -> B0
proj1_sig
  (coerce plength_eq_length (map f t)
   in Batch_contents (toBatch (map f t))) =
proj1_sig
  (map f
     (coerce plength_eq_length t
      in Batch_contents (toBatch t)))
      rewrite <- coerce_Vector_contents.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A0, B0: Type
t: T A0
f: A0 -> B0
proj1_sig (Batch_contents (toBatch (map f t))) =
proj1_sig
  (map f
     (coerce plength_eq_length t
      in Batch_contents (toBatch t)))
      rewrite <- map_coerce_Vector.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A0, B0: Type
t: T A0
f: A0 -> B0
proj1_sig (Batch_contents (toBatch (map f t))) =
proj1_sig (map f (Batch_contents (toBatch t)))
      compose near t on left.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A0, B0: Type
t: T A0
f: A0 -> B0
proj1_sig (Batch_contents ((toBatch ∘ map f) t)) =
proj1_sig (map f (Batch_contents (toBatch t)))
      rewrite toBatch_mapfst.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A0, B0: Type
t: T A0
f: A0 -> B0
proj1_sig
  (Batch_contents ((mapfst_Batch f ∘ toBatch) t)) =
proj1_sig (map f (Batch_contents (toBatch t)))
      unfold compose at 2.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A0, B0: Type
t: T A0
f: A0 -> B0
proj1_sig
  (Batch_contents (mapfst_Batch f (toBatch t))) =
proj1_sig (map f (Batch_contents (toBatch t)))
      rewrite Batch_contents_natural.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A0, B0: Type
t: T A0
f: A0 -> B0
proj1_sig
  (Batch_contents (mapfst_Batch f (toBatch t))) =
proj1_sig
  (Batch_contents (mapfst_Batch f (toBatch t)))
      reflexivity.
    Qed.

    Lemma trav_make_natural:
      forall (A B C: Type) (t: T A) (f: B -> C) (v: Vector (plength t) B),
        trav_make t (map f v) = map f (trav_make t v).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
forall (A B C : Type) (t : T A) (f : B -> C)
  (v : Vector (plength t) B),
trav_make t (map f v) = map f (trav_make t v)
    Proof.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
forall (A B C : Type) (t : T A) (f : B -> C)
  (v : Vector (plength t) B),
trav_make t (map f v) = map f (trav_make t v)
      intros.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A0, B0, C: Type
t: T A0
f: B0 -> C
v: Vector (plength t) B0
trav_make t (map f v) = map f (trav_make t v)
      unfold trav_make.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A0, B0, C: Type
t: T A0
f: B0 -> C
v: Vector (plength t) B0
Batch_make (toBatch t)
  (coerce eq_sym (plength_eq_length t) in map f v) =
map f
  (Batch_make (toBatch t)
     (coerce eq_sym (plength_eq_length t) in v))
      rewrite (Batch_make_natural_rw1 (toBatch t) (map f)).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A0, B0, C: Type
t: T A0
f: B0 -> C
v: Vector (plength t) B0
Batch_make (toBatch t)
  (coerce eq_sym (plength_eq_length t) in map f v) =
Batch_make (map (map f) (toBatch t))
  (coerce batch_length_map (map f) (toBatch t)
   in coerce eq_sym (plength_eq_length t) in v)
      assert (cut: map (map f) (toBatch t) =
                     mapsnd_Batch f (toBatch t)).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A0, B0, C: Type
t: T A0
f: B0 -> C
v: Vector (plength t) B0
map (map f) (toBatch t) = mapsnd_Batch f (toBatch t)
T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A0, B0, C: Type
t: T A0
f: B0 -> C
v: Vector (plength t) B0
cut: map (map f) (toBatch t) =
mapsnd_Batch f (toBatch t)
Batch_make (toBatch t)
  (coerce eq_sym (plength_eq_length t) in map f v) =
Batch_make (map (map f) (toBatch t))
  (coerce batch_length_map (map f) (toBatch t)
   in coerce eq_sym (plength_eq_length t) in v)
      {T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A0, B0, C: Type
t: T A0
f: B0 -> C
v: Vector (plength t) B0
map (map f) (toBatch t) = mapsnd_Batch f (toBatch t) compose near t.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A0, B0, C: Type
t: T A0
f: B0 -> C
v: Vector (plength t) B0
(map (map f) ∘ toBatch) t =
(mapsnd_Batch f ∘ toBatch) t
        now rewrite (toBatch_mapsnd). }T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A0, B0, C: Type
t: T A0
f: B0 -> C
v: Vector (plength t) B0
cut: map (map f) (toBatch t) =
mapsnd_Batch f (toBatch t)
Batch_make (toBatch t)
  (coerce eq_sym (plength_eq_length t) in map f v) =
Batch_make (map (map f) (toBatch t))
  (coerce batch_length_map (map f) (toBatch t)
   in coerce eq_sym (plength_eq_length t) in v)
      rewrite (Batch_make_rw
                 (map (map f) (toBatch t))
                 (mapsnd_Batch f (toBatch t))
                 cut).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A0, B0, C: Type
t: T A0
f: B0 -> C
v: Vector (plength t) B0
cut: map (map f) (toBatch t) =
mapsnd_Batch f (toBatch t)
Batch_make (toBatch t)
  (coerce eq_sym (plength_eq_length t) in map f v) =
Batch_make (mapsnd_Batch f (toBatch t))
  (coerce eq_ind_r
            (fun z : Batch A0 B0 (T C) =>
             length_Batch z =
             length_Batch (mapsnd_Batch f (toBatch t)))
            eq_refl cut
   in coerce batch_length_map (map f) (toBatch t)
      in coerce eq_sym (plength_eq_length t) in v)
      rewrite coerce_Vector_compose.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A0, B0, C: Type
t: T A0
f: B0 -> C
v: Vector (plength t) B0
cut: map (map f) (toBatch t) =
mapsnd_Batch f (toBatch t)
Batch_make (toBatch t)
  (coerce eq_sym (plength_eq_length t) in map f v) =
Batch_make (mapsnd_Batch f (toBatch t))
  (coerce eq_trans
            (batch_length_map (map f) (toBatch t))
            (eq_ind_r
               (fun z : Batch A0 B0 (T C) =>
                length_Batch z =
                length_Batch
                  (mapsnd_Batch f (toBatch t)))
               eq_refl cut)
   in coerce eq_sym (plength_eq_length t) in v)
      rewrite coerce_Vector_compose.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A0, B0, C: Type
t: T A0
f: B0 -> C
v: Vector (plength t) B0
cut: map (map f) (toBatch t) =
mapsnd_Batch f (toBatch t)
Batch_make (toBatch t)
  (coerce eq_sym (plength_eq_length t) in map f v) =
Batch_make (mapsnd_Batch f (toBatch t))
  (coerce eq_trans (eq_sym (plength_eq_length t))
            (eq_trans
               (batch_length_map (map f) (toBatch t))
               (eq_ind_r
                  (fun z : Batch A0 B0 (T C) =>
                   length_Batch z =
                   length_Batch
                     (mapsnd_Batch f (toBatch t)))
                  eq_refl cut)) in v)
      rewrite Batch_make_natural2.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A0, B0, C: Type
t: T A0
f: B0 -> C
v: Vector (plength t) B0
cut: map (map f) (toBatch t) =
mapsnd_Batch f (toBatch t)
Batch_make (toBatch t)
  (coerce eq_sym (plength_eq_length t) in map f v) =
Batch_make (toBatch t)
  (coerce eq_sym (batch_length_mapsnd f (toBatch t))
   in map f
        (coerce eq_trans
                  (eq_sym (plength_eq_length t))
                  (eq_trans
                     (batch_length_map (map f)
                        (toBatch t))
                     (eq_ind_r
                        (fun z : Batch A0 B0 (T C) =>
                         length_Batch z =
                         length_Batch
                           (mapsnd_Batch f (toBatch t)))
                        eq_refl cut)) in v))
      apply Batch_make_sim1.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A0, B0, C: Type
t: T A0
f: B0 -> C
v: Vector (plength t) B0
cut: map (map f) (toBatch t) =
mapsnd_Batch f (toBatch t)
coerce eq_sym (plength_eq_length t) in map f v ~~
coerce eq_sym (batch_length_mapsnd f (toBatch t))
in map f
     (coerce eq_trans (eq_sym (plength_eq_length t))
               (eq_trans
                  (batch_length_map (map f)
                     (toBatch t))
                  (eq_ind_r
                     (fun z : Batch A0 B0 (T C) =>
                      length_Batch z =
                      length_Batch
                        (mapsnd_Batch f (toBatch t)))
                     eq_refl cut)) in v)
      apply Vector_coerce_sim_r'.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A0, B0, C: Type
t: T A0
f: B0 -> C
v: Vector (plength t) B0
cut: map (map f) (toBatch t) =
mapsnd_Batch f (toBatch t)
coerce eq_sym (plength_eq_length t) in map f v ~~
map f
  (coerce eq_trans (eq_sym (plength_eq_length t))
            (eq_trans
               (batch_length_map (map f) (toBatch t))
               (eq_ind_r
                  (fun z : Batch A0 B0 (T C) =>
                   length_Batch z =
                   length_Batch
                     (mapsnd_Batch f (toBatch t)))
                  eq_refl cut)) in v)
      apply Vector_coerce_sim_l'.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, A0, B0, C: Type
t: T A0
f: B0 -> C
v: Vector (plength t) B0
cut: map (map f) (toBatch t) =
mapsnd_Batch f (toBatch t)
map f v ~~
map f
  (coerce eq_trans (eq_sym (plength_eq_length t))
            (eq_trans
               (batch_length_map (map f) (toBatch t))
               (eq_ind_r
                  (fun z : Batch A0 B0 (T C) =>
                   length_Batch z =
                   length_Batch
                     (mapsnd_Batch f (toBatch t)))
                  eq_refl cut)) in v)
      apply map_coerce_Vector.
    Qed.

  End trav_make_lemmas.

  (** ** Relating <<tolist>> and <<trav_contents>> *)
  (********************************************************************)
  Lemma tolist_trav_contents `{t: T A}:
    Vector_to_list A (trav_contents t) = List.rev (tolist t).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
Vector_to_list A (trav_contents t) =
List.rev (tolist t)
  Proof.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
Vector_to_list A (trav_contents t) =
List.rev (tolist t)
    intros.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
Vector_to_list A (trav_contents t) =
List.rev (tolist t)
    unfold Vector_to_list.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
proj1_sig (trav_contents t) = List.rev (tolist t)
    unfold trav_contents.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
proj1_sig
  (coerce plength_eq_length t
   in Batch_contents (toBatch t)) =
List.rev (tolist t)
    rewrite <- coerce_Vector_contents.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
proj1_sig (Batch_contents (toBatch t)) =
List.rev (tolist t)
    rewrite tolist_Batch_contents.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
List.rev (tolist (toBatch t)) = List.rev (tolist t)
    rewrite <- tolist_through_toBatch.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
List.rev (tolist t) = List.rev (tolist t)
    reflexivity.
  Qed.

  (** ** Lens-like laws *)
  (********************************************************************)
  Section lens_laws.

    (** *** get-put *)
    (******************************************************************)
    Lemma trav_get_put `{t: T A}:
      trav_make t (trav_contents t) = t.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
trav_make t (trav_contents t) = t
    Proof.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
trav_make t (trav_contents t) = t
      unfold trav_make, trav_contents.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
Batch_make (toBatch t)
  (coerce eq_sym (plength_eq_length t)
   in coerce plength_eq_length t
      in Batch_contents (toBatch t)) = t
      rewrite coerce_Vector_compose.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
Batch_make (toBatch t)
  (coerce eq_trans (plength_eq_length t)
            (eq_sym (plength_eq_length t))
   in Batch_contents (toBatch t)) = t
      hide_lhs;
        change t with (id t);
        rewrite <- TraversableFunctor.trf_extract;
        rewrite Heqlhs; clear Heqlhs lhs;
        unfold compose at 1.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
Batch_make (toBatch t)
  (coerce eq_trans (plength_eq_length t)
            (eq_sym (plength_eq_length t))
   in Batch_contents (toBatch t)) =
extract_Batch (toBatch t)
      rewrite <- Batch_make_contents.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
Batch_make (toBatch t)
  (coerce eq_trans (plength_eq_length t)
            (eq_sym (plength_eq_length t))
   in Batch_contents (toBatch t)) =
Batch_make (toBatch t) (Batch_contents (toBatch t))
      apply Batch_make_sim1.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
coerce eq_trans (plength_eq_length t)
         (eq_sym (plength_eq_length t))
in Batch_contents (toBatch t) ~~
Batch_contents (toBatch t)
      vector_sim.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
Batch_contents (toBatch t) ~~
Batch_contents (toBatch t)
      apply Batch_contents_toBatch_sim.
    Qed.

    (** *** put-get *)
    (******************************************************************)
    Lemma trav_contents_make {A B} {t: T A} {v: Vector (plength t) B}:
      trav_contents (trav_make t v) ~~ v.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
v: Vector (plength t) B
trav_contents (trav_make t v) ~~ v
    Proof.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
v: Vector (plength t) B
trav_contents (trav_make t v) ~~ v
      unfold trav_contents.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
v: Vector (plength t) B
coerce plength_eq_length (trav_make t v)
in Batch_contents (toBatch (trav_make t v)) ~~ v
      vector_sim.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
v: Vector (plength t) B
Batch_contents (toBatch (trav_make t v)) ~~ v
      rewrite toBatch_trav_make_to_replace_contents.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
v: Vector (plength t) B
Batch_contents
  (Batch_replace_contents (toBatch t)
     (coerce eq_sym (plength_eq_length t) in v)) ~~ v
      rewrite Batch_put_get.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
v: Vector (plength t) B
coerce length_replace_contents (toBatch t)
         (coerce eq_sym (plength_eq_length t) in v)
in coerce eq_sym (plength_eq_length t) in v ~~ v
      vector_sim.
    Qed.

    (** *** put-put *)
    (******************************************************************)
    Lemma trav_make_make_
            `(t: T A) `(v: Vector (plength t) B)
            `(v1: Vector (plength (trav_make t v)) B')
            (v2: Vector (plength t) B')
            (pf: v1 ~~ v2):
      trav_make (trav_make t v) v1 =
        trav_make t v2.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
B: Type
v: Vector (plength t) B
B': Type
v1: Vector (plength (trav_make t v)) B'
v2: Vector (plength t) B'
pf: v1 ~~ v2
trav_make (trav_make t v) v1 = trav_make t v2
    Proof.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
B: Type
v: Vector (plength t) B
B': Type
v1: Vector (plength (trav_make t v)) B'
v2: Vector (plength t) B'
pf: v1 ~~ v2
trav_make (trav_make t v) v1 = trav_make t v2
      unfold trav_make at 1.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
B: Type
v: Vector (plength t) B
B': Type
v1: Vector (plength (trav_make t v)) B'
v2: Vector (plength t) B'
pf: v1 ~~ v2
Batch_make (toBatch (trav_make t v))
  (coerce eq_sym (plength_eq_length (trav_make t v))
   in v1) = trav_make t v2
      unfold trav_make at 7.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
B: Type
v: Vector (plength t) B
B': Type
v1: Vector (plength (trav_make t v)) B'
v2: Vector (plength t) B'
pf: v1 ~~ v2
Batch_make (toBatch (trav_make t v))
  (coerce eq_sym (plength_eq_length (trav_make t v))
   in v1) =
Batch_make (toBatch t)
  (coerce eq_sym (plength_eq_length t) in v2)
      apply Batch_make_sim3.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
B: Type
v: Vector (plength t) B
B': Type
v1: Vector (plength (trav_make t v)) B'
v2: Vector (plength t) B'
pf: v1 ~~ v2
shape (toBatch (trav_make t v)) = shape (toBatch t)
T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
B: Type
v: Vector (plength t) B
B': Type
v1: Vector (plength (trav_make t v)) B'
v2: Vector (plength t) B'
pf: v1 ~~ v2
coerce eq_sym (plength_eq_length (trav_make t v))
in v1 ~~ coerce eq_sym (plength_eq_length t) in v2
      -T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
B: Type
v: Vector (plength t) B
B': Type
v1: Vector (plength (trav_make t v)) B'
v2: Vector (plength t) B'
pf: v1 ~~ v2
shape (toBatch (trav_make t v)) = shape (toBatch t) symmetry.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
B: Type
v: Vector (plength t) B
B': Type
v1: Vector (plength (trav_make t v)) B'
v2: Vector (plength t) B'
pf: v1 ~~ v2
shape (toBatch t) = shape (toBatch (trav_make t v))
        rewrite toBatch_trav_make_to_replace_contents.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
B: Type
v: Vector (plength t) B
B': Type
v1: Vector (plength (trav_make t v)) B'
v2: Vector (plength t) B'
pf: v1 ~~ v2
shape (toBatch t) =
shape
  (Batch_replace_contents (toBatch t)
     (coerce eq_sym (plength_eq_length t) in v))
        apply Batch_shape_replace_contents.
      -T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
B: Type
v: Vector (plength t) B
B': Type
v1: Vector (plength (trav_make t v)) B'
v2: Vector (plength t) B'
pf: v1 ~~ v2
coerce eq_sym (plength_eq_length (trav_make t v))
in v1 ~~ coerce eq_sym (plength_eq_length t) in v2 vector_sim.
    Qed.

    Lemma plength_trav_make: forall `(t: T A) `(v: Vector _ B),
        plength t = plength (trav_make t v).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A : Type) (t : T A) (B : Type)
  (v : Vector (plength t) B),
plength t = plength (trav_make t v)
    Proof.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A : Type) (t : T A) (B : Type)
  (v : Vector (plength t) B),
plength t = plength (trav_make t v)
      intros.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
B: Type
v: Vector (plength t) B
plength t = plength (trav_make t v)
      unfold plength at 1 2.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
B: Type
v: Vector (plength t) B
mapReduce (fun _ : A => 1) t =
mapReduce (fun _ : B => 1) (trav_make t v)
      do 2 change (fun (x:?X) => 1) with (const (A := X) 1).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
B: Type
v: Vector (plength t) B
mapReduce (const 1) t =
mapReduce (const 1) (trav_make t v)
      do 2 rewrite (mapReduce_through_runBatch2 _ B).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
B: Type
v: Vector (plength t) B
(runBatch (const 1) ∘ toBatch) t =
(runBatch (const 1) ∘ toBatch) (trav_make t v)
      unfold compose.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
B: Type
v: Vector (plength t) B
runBatch (const 1) (toBatch t) =
runBatch (const 1) (toBatch (trav_make t v))
      rewrite (@toBatch_trav_make_to_replace_contents A B B t v).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
B: Type
v: Vector (plength t) B
runBatch (const 1) (toBatch t) =
runBatch (const 1)
  (Batch_replace_contents (toBatch t)
     (coerce eq_sym (plength_eq_length t) in v))
      rewrite <- (runBatch_const_contents (G := @const Type Type nat)).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
B: Type
v: Vector (plength t) B
runBatch (const 1) (toBatch t) =
runBatch (const 1) (toBatch t)
      reflexivity.
    Qed.

    Lemma trav_make_make:
      forall `(t: T A) `(v: Vector (plength t) B) (C: Type),
      trav_make (B := C) (trav_make t v) ~!~
        trav_make t.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A : Type) (t : T A) (B : Type)
  (v : Vector (plength t) B) (C : Type),
trav_make (trav_make t v) ~!~ trav_make t
    Proof.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A : Type) (t : T A) (B : Type)
  (v : Vector (plength t) B) (C : Type),
trav_make (trav_make t v) ~!~ trav_make t
      intros.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
B: Type
v: Vector (plength t) B
C: Type
trav_make (trav_make t v) ~!~ trav_make t
      unfold Vector_fun_sim.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
B: Type
v: Vector (plength t) B
C: Type
plength (trav_make t v) = plength t /\
(forall (v1 : Vector (plength (trav_make t v)) C)
   (v2 : Vector (plength t) C),
 v1 ~~ v2 ->
 trav_make (trav_make t v) v1 = trav_make t v2) split.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
B: Type
v: Vector (plength t) B
C: Type
plength (trav_make t v) = plength t
T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
B: Type
v: Vector (plength t) B
C: Type
forall (v1 : Vector (plength (trav_make t v)) C)
  (v2 : Vector (plength t) C),
v1 ~~ v2 ->
trav_make (trav_make t v) v1 = trav_make t v2
      -T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
B: Type
v: Vector (plength t) B
C: Type
plength (trav_make t v) = plength t rewrite <- plength_trav_make.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
B: Type
v: Vector (plength t) B
C: Type
plength t = plength t
        reflexivity.
      -T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
B: Type
v: Vector (plength t) B
C: Type
forall (v1 : Vector (plength (trav_make t v)) C)
  (v2 : Vector (plength t) C),
v1 ~~ v2 ->
trav_make (trav_make t v) v1 = trav_make t v2 intros.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
B: Type
v: Vector (plength t) B
C: Type
v1: Vector (plength (trav_make t v)) C
v2: Vector (plength t) C
H2: v1 ~~ v2
trav_make (trav_make t v) v1 = trav_make t v2
        now rewrite (trav_make_make_ t v v1 v2).
    Qed.

    (** ** Lemmas regarding <<shape>> and <<trav_make>> *)
    (******************************************************************)
    Lemma trav_same_shape {A1 A2: Type}
      {t1: T A1} {t2: T A2}:
      shape t1 = shape t2 ->
      forall B, trav_make (B := B) t1 ~!~ trav_make t2.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2: Type
t1: T A1
t2: T A2
shape t1 = shape t2 ->
forall B : Type, trav_make t1 ~!~ trav_make t2
    Proof.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2: Type
t1: T A1
t2: T A2
shape t1 = shape t2 ->
forall B : Type, trav_make t1 ~!~ trav_make t2
      intros.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2: Type
t1: T A1
t2: T A2
H2: shape t1 = shape t2
B: Type
trav_make t1 ~!~ trav_make t2
      unfold trav_make.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2: Type
t1: T A1
t2: T A2
H2: shape t1 = shape t2
B: Type
(Batch_make (toBatch t1)
 ○ coerce_Vector_length
     (eq_sym (plength_eq_length t1))) ~!~
(Batch_make (toBatch t2)
 ○ coerce_Vector_length
     (eq_sym (plength_eq_length t2)))
      apply Vector_coerce_fun_sim_l'.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2: Type
t1: T A1
t2: T A2
H2: shape t1 = shape t2
B: Type
Batch_make (toBatch t1) ~!~
(Batch_make (toBatch t2)
 ○ coerce_Vector_length
     (eq_sym (plength_eq_length t2)))
      apply Vector_coerce_fun_sim_r'.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2: Type
t1: T A1
t2: T A2
H2: shape t1 = shape t2
B: Type
Batch_make (toBatch t1) ~!~ Batch_make (toBatch t2)
      apply Batch_make_shape.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2: Type
t1: T A1
t2: T A2
H2: shape t1 = shape t2
B: Type
shape (toBatch t1) = shape (toBatch t2)
      apply same_shape_toBatch.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2: Type
t1: T A1
t2: T A2
H2: shape t1 = shape t2
B: Type
shape t1 = shape t2
      assumption.
    Qed.

    (** ** Lemmas regarding <<trav_make>> *)
    (****************************************************************)
    Section trav_make_lemmas.

      Context
        {A B: Type}.

      Lemma trav_make_sim1:
        forall (t: T A) `{v1 ~~ v2},
          trav_make (B := B) t v1 = trav_make t v2.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
forall (t : T A) (v1 v2 : Vector (plength t) B),
v1 ~~ v2 -> trav_make t v1 = trav_make t v2
      Proof.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
forall (t : T A) (v1 v2 : Vector (plength t) B),
v1 ~~ v2 -> trav_make t v1 = trav_make t v2
        intros.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
v1, v2: Vector (plength t) B
H2: v1 ~~ v2
trav_make t v1 = trav_make t v2
        unfold trav_make.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
v1, v2: Vector (plength t) B
H2: v1 ~~ v2
Batch_make (toBatch t)
  (coerce eq_sym (plength_eq_length t) in v1) =
Batch_make (toBatch t)
  (coerce eq_sym (plength_eq_length t) in v2)
        apply Batch_make_sim1.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
v1, v2: Vector (plength t) B
H2: v1 ~~ v2
coerce eq_sym (plength_eq_length t) in v1 ~~
coerce eq_sym (plength_eq_length t) in v2
        vector_sim.
      Qed.

      Lemma trav_make_sim2:
        forall `(t1: T A) (t2: T A)
          `(v1: Vector (plength t1) B)
          `(v2: Vector (plength t2) B),
          t1 = t2 ->
          Vector_sim v1 v2 ->
          trav_make t1 v1 = trav_make t2 v2.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
forall (t1 t2 : T A) (v1 : Vector (plength t1) B)
  (v2 : Vector (plength t2) B),
t1 = t2 ->
v1 ~~ v2 -> trav_make t1 v1 = trav_make t2 v2
      Proof.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
forall (t1 t2 : T A) (v1 : Vector (plength t1) B)
  (v2 : Vector (plength t2) B),
t1 = t2 ->
v1 ~~ v2 -> trav_make t1 v1 = trav_make t2 v2
        intros.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t1, t2: T A
v1: Vector (plength t1) B
v2: Vector (plength t2) B
H2: t1 = t2
H3: v1 ~~ v2
trav_make t1 v1 = trav_make t2 v2
        subst.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t2: T A
v1, v2: Vector (plength t2) B
H3: v1 ~~ v2
trav_make t2 v1 = trav_make t2 v2
        now apply trav_make_sim1.
      Qed.

    End trav_make_lemmas.

  End lens_laws.

  (** ** Representation theorems *)
  (********************************************************************)
  Lemma traverse_repr:
    forall `{Applicative G} (A B: Type) (t: T A) (f: A -> G B),
      traverse f t =
        map (trav_make t) (forwards (traverse (mkBackwards ∘ f) (trav_contents t))).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (G : Type -> Type) (Map_G : Map G)
  (Pure_G : Pure G) (Mult_G : Mult G),
Applicative G ->
forall (A B : Type) (t : T A) (f : A -> G B),
traverse f t =
map (trav_make t)
  (forwards
     (traverse (mkBackwards ∘ f) (trav_contents t)))
  Proof.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (G : Type -> Type) (Map_G : Map G)
  (Pure_G : Pure G) (Mult_G : Mult G),
Applicative G ->
forall (A B : Type) (t : T A) (f : A -> G B),
traverse f t =
map (trav_make t)
  (forwards
     (traverse (mkBackwards ∘ f) (trav_contents t)))
    intros.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H2: Applicative G
A, B: Type
t: T A
f: A -> G B
traverse f t =
map (trav_make t)
  (forwards
     (traverse (mkBackwards ∘ f) (trav_contents t)))
    rewrite traverse_through_runBatch.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H2: Applicative G
A, B: Type
t: T A
f: A -> G B
(runBatch f ∘ toBatch) t =
map (trav_make t)
  (forwards
     (traverse (mkBackwards ∘ f) (trav_contents t)))
    unfold compose at 1.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H2: Applicative G
A, B: Type
t: T A
f: A -> G B
runBatch f (toBatch t) =
map (trav_make t)
  (forwards
     (traverse (mkBackwards ∘ f) (trav_contents t)))
    rewrite runBatch_repr2.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H2: Applicative G
A, B: Type
t: T A
f: A -> G B
map (Batch_make (toBatch t))
  (forwards
     (traverse (mkBackwards ∘ f)
        (Batch_contents (toBatch t)))) =
map (trav_make t)
  (forwards
     (traverse (mkBackwards ∘ f) (trav_contents t)))
    unfold trav_make, trav_contents.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H2: Applicative G
A, B: Type
t: T A
f: A -> G B
map (Batch_make (toBatch t))
  (forwards
     (traverse (mkBackwards ∘ f)
        (Batch_contents (toBatch t)))) =
map
  (Batch_make (toBatch t)
   ○ coerce_Vector_length
       (eq_sym (plength_eq_length t)))
  (forwards
     (traverse (mkBackwards ∘ f)
        (coerce plength_eq_length t
         in Batch_contents (toBatch t))))
    rewrite (traverse_Vector_coerce _ _ _ (plength_eq_length t)).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H2: Applicative G
A, B: Type
t: T A
f: A -> G B
map (Batch_make (toBatch t))
  (forwards
     (map
        (fun v : Vector (plength t) B =>
         coerce eq_sym (plength_eq_length t) in v)
        (traverse (mkBackwards ∘ f)
           (coerce plength_eq_length t
            in Batch_contents (toBatch t))))) =
map
  (Batch_make (toBatch t)
   ○ coerce_Vector_length
       (eq_sym (plength_eq_length t)))
  (forwards
     (traverse (mkBackwards ∘ f)
        (coerce plength_eq_length t
         in Batch_contents (toBatch t))))
    change_left (
        map (Batch_make (toBatch t))
          (map
             (fun v: Vector (plength t) B =>
                coerce eq_sym (plength_eq_length (B := B) t) in v)
             (forwards
                (traverse (mkBackwards ∘ f)
                   (coerce (plength_eq_length (B := B) t) in
                     Batch_contents (toBatch t)))))).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H2: Applicative G
A, B: Type
t: T A
f: A -> G B
map (Batch_make (toBatch t))
  (map
     (fun v : Vector (plength t) B =>
      coerce eq_sym (plength_eq_length t) in v)
     (forwards
        (traverse (mkBackwards ∘ f)
           (coerce plength_eq_length t
            in Batch_contents (toBatch t))))) =
map
  (Batch_make (toBatch t)
   ○ coerce_Vector_length
       (eq_sym (plength_eq_length t)))
  (forwards
     (traverse (mkBackwards ∘ f)
        (coerce plength_eq_length t
         in Batch_contents (toBatch t))))
    compose near ((forwards
                     (traverse (mkBackwards ∘ f)
                        (coerce (plength_eq_length (B := B) t)
                          in Batch_contents (toBatch t))))).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H2: Applicative G
A, B: Type
t: T A
f: A -> G B
(map (Batch_make (toBatch t))
 ∘ map
     (fun v : Vector (plength t) B =>
      coerce eq_sym (plength_eq_length t) in v))
  (forwards
     (traverse (mkBackwards ∘ f)
        (coerce plength_eq_length t
         in Batch_contents (toBatch t)))) =
map
  (Batch_make (toBatch t)
   ○ coerce_Vector_length
       (eq_sym (plength_eq_length t)))
  (forwards
     (traverse (mkBackwards ∘ f)
        (coerce plength_eq_length t
         in Batch_contents (toBatch t))))
    rewrite (fun_map_map).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H2: Applicative G
A, B: Type
t: T A
f: A -> G B
map
  (Batch_make (toBatch t)
   ∘ (fun v : Vector (plength t) B =>
      coerce eq_sym (plength_eq_length t) in v))
  (forwards
     (traverse (mkBackwards ∘ f)
        (coerce plength_eq_length t
         in Batch_contents (toBatch t)))) =
map
  (Batch_make (toBatch t)
   ○ coerce_Vector_length
       (eq_sym (plength_eq_length t)))
  (forwards
     (traverse (mkBackwards ∘ f)
        (coerce plength_eq_length t
         in Batch_contents (toBatch t))))
    fequal.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H2: Applicative G
A, B: Type
t: T A
f: A -> G B
forwards
  (traverse (mkBackwards ∘ f)
     (coerce plength_eq_length t
      in Batch_contents (toBatch t))) =
forwards
  (traverse (mkBackwards ∘ f)
     (coerce plength_eq_length t
      in Batch_contents (toBatch t)))
    fequal.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H2: Applicative G
A, B: Type
t: T A
f: A -> G B
traverse (mkBackwards ∘ f)
  (coerce plength_eq_length t
   in Batch_contents (toBatch t)) =
traverse (mkBackwards ∘ f)
  (coerce plength_eq_length t
   in Batch_contents (toBatch t))
    fequal.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H2: Applicative G
A, B: Type
t: T A
f: A -> G B
coerce plength_eq_length t
in Batch_contents (toBatch t) =
coerce plength_eq_length t
in Batch_contents (toBatch t)
    apply Vector_eq.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H2: Applicative G
A, B: Type
t: T A
f: A -> G B
proj1_sig
  (coerce plength_eq_length t
   in Batch_contents (toBatch t)) =
proj1_sig
  (coerce plength_eq_length t
   in Batch_contents (toBatch t))
    apply Vector_coerce_sim_l'.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H2: Applicative G
A, B: Type
t: T A
f: A -> G B
Batch_contents (toBatch t) ~~
coerce plength_eq_length t
in Batch_contents (toBatch t)
    apply Vector_coerce_sim_r'.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H2: Applicative G
A, B: Type
t: T A
f: A -> G B
Batch_contents (toBatch t) ~~
Batch_contents (toBatch t)
    eapply Batch_contents_toBatch_sim.
  Qed.

  (** ** Corollary: Spec for <<traverse>> After Applying <<trav_make>> *)
  (********************************************************************)
  Corollary traverse_trav_make:
    forall `{Applicative G} (X A B: Type)
      (t: T X) (f: A -> G B) (v: Vector (plength t) A),
      traverse (T := T) f (trav_make t v) =
        map (trav_make t) (forwards (traverse (mkBackwards ∘ f) v)).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (G : Type -> Type) (Map_G : Map G)
  (Pure_G : Pure G) (Mult_G : Mult G),
Applicative G ->
forall (X A B : Type) (t : T X) (f : A -> G B)
  (v : Vector (plength t) A),
traverse f (trav_make t v) =
map (trav_make t)
  (forwards (traverse (mkBackwards ∘ f) v))
  Proof.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (G : Type -> Type) (Map_G : Map G)
  (Pure_G : Pure G) (Mult_G : Mult G),
Applicative G ->
forall (X A B : Type) (t : T X) (f : A -> G B)
  (v : Vector (plength t) A),
traverse f (trav_make t v) =
map (trav_make t)
  (forwards (traverse (mkBackwards ∘ f) v))
    intros.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H2: Applicative G
X, A, B: Type
t: T X
f: A -> G B
v: Vector (plength t) A
traverse f (trav_make t v) =
map (trav_make t)
  (forwards (traverse (mkBackwards ∘ f) v))
    rewrite traverse_repr.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H2: Applicative G
X, A, B: Type
t: T X
f: A -> G B
v: Vector (plength t) A
map (trav_make (trav_make t v))
  (forwards
     (traverse (mkBackwards ∘ f)
        (trav_contents (trav_make t v)))) =
map (trav_make t)
  (forwards (traverse (mkBackwards ∘ f) v))
    assert (Hlen: plength (trav_make t v) = plength t).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H2: Applicative G
X, A, B: Type
t: T X
f: A -> G B
v: Vector (plength t) A
plength (trav_make t v) = plength t
T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H2: Applicative G
X, A, B: Type
t: T X
f: A -> G B
v: Vector (plength t) A
Hlen: plength (trav_make t v) = plength t
map (trav_make (trav_make t v))
  (forwards
     (traverse (mkBackwards ∘ f)
        (trav_contents (trav_make t v)))) =
map (trav_make t)
  (forwards (traverse (mkBackwards ∘ f) v))
    {T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H2: Applicative G
X, A, B: Type
t: T X
f: A -> G B
v: Vector (plength t) A
plength (trav_make t v) = plength t now rewrite <- plength_trav_make. }T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H2: Applicative G
X, A, B: Type
t: T X
f: A -> G B
v: Vector (plength t) A
Hlen: plength (trav_make t v) = plength t
map (trav_make (trav_make t v))
  (forwards
     (traverse (mkBackwards ∘ f)
        (trav_contents (trav_make t v)))) =
map (trav_make t)
  (forwards (traverse (mkBackwards ∘ f) v))
    rewrite (map_sim_function B (T B) _ _ (trav_make (trav_make t v))
               (trav_make t (B := B)) Hlen).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H2: Applicative G
X, A, B: Type
t: T X
f: A -> G B
v: Vector (plength t) A
Hlen: plength (trav_make t v) = plength t
map (trav_make t ○ coerce_Vector_length Hlen)
  (forwards
     (traverse (mkBackwards ∘ f)
        (trav_contents (trav_make t v)))) =
map (trav_make t)
  (forwards (traverse (mkBackwards ∘ f) v))
T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H2: Applicative G
X, A, B: Type
t: T X
f: A -> G B
v: Vector (plength t) A
Hlen: plength (trav_make t v) = plength t
trav_make (trav_make t v) ~!~ trav_make t
    2: {T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H2: Applicative G
X, A, B: Type
t: T X
f: A -> G B
v: Vector (plength t) A
Hlen: plength (trav_make t v) = plength t
trav_make (trav_make t v) ~!~ trav_make t apply trav_make_make. }T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H2: Applicative G
X, A, B: Type
t: T X
f: A -> G B
v: Vector (plength t) A
Hlen: plength (trav_make t v) = plength t
map (trav_make t ○ coerce_Vector_length Hlen)
  (forwards
     (traverse (mkBackwards ∘ f)
        (trav_contents (trav_make t v)))) =
map (trav_make t)
  (forwards (traverse (mkBackwards ∘ f) v))
    change (?f ○ ?pre) with (f ∘ pre).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H2: Applicative G
X, A, B: Type
t: T X
f: A -> G B
v: Vector (plength t) A
Hlen: plength (trav_make t v) = plength t
map (trav_make t ∘ coerce_Vector_length Hlen)
  (forwards
     (traverse (mkBackwards ∘ f)
        (trav_contents (trav_make t v)))) =
map (trav_make t)
  (forwards (traverse (mkBackwards ∘ f) v))
    rewrite <- (fun_map_map).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H2: Applicative G
X, A, B: Type
t: T X
f: A -> G B
v: Vector (plength t) A
Hlen: plength (trav_make t v) = plength t
(map (trav_make t) ∘ map (coerce_Vector_length Hlen))
  (forwards
     (traverse (mkBackwards ∘ f)
        (trav_contents (trav_make t v)))) =
map (trav_make t)
  (forwards (traverse (mkBackwards ∘ f) v))
    unfold compose at 1.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H2: Applicative G
X, A, B: Type
t: T X
f: A -> G B
v: Vector (plength t) A
Hlen: plength (trav_make t v) = plength t
map (trav_make t)
  (map (coerce_Vector_length Hlen)
     (forwards
        (traverse (mkBackwards ∘ f)
           (trav_contents (trav_make t v))))) =
map (trav_make t)
  (forwards (traverse (mkBackwards ∘ f) v))
    fequal.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H2: Applicative G
X, A, B: Type
t: T X
f: A -> G B
v: Vector (plength t) A
Hlen: plength (trav_make t v) = plength t
map (coerce_Vector_length Hlen)
  (forwards
     (traverse (mkBackwards ∘ f)
        (trav_contents (trav_make t v)))) =
forwards (traverse (mkBackwards ∘ f) v)
    compose near (traverse (mkBackwards ∘ f) (trav_contents (trav_make t v))).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H2: Applicative G
X, A, B: Type
t: T X
f: A -> G B
v: Vector (plength t) A
Hlen: plength (trav_make t v) = plength t
(map (coerce_Vector_length Hlen) ∘ forwards)
  (traverse (mkBackwards ∘ f)
     (trav_contents (trav_make t v))) =
forwards (traverse (mkBackwards ∘ f) v)
    rewrite (natural (Natural := Natural_forwards)).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H2: Applicative G
X, A, B: Type
t: T X
f: A -> G B
v: Vector (plength t) A
Hlen: plength (trav_make t v) = plength t
(forwards ∘ map (coerce_Vector_length Hlen))
  (traverse (mkBackwards ∘ f)
     (trav_contents (trav_make t v))) =
forwards (traverse (mkBackwards ∘ f) v)
    unfold compose.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H2: Applicative G
X, A, B: Type
t: T X
f: A -> G B
v: Vector (plength t) A
Hlen: plength (trav_make t v) = plength t
forwards
  (map (coerce_Vector_length Hlen)
     (traverse (mkBackwards ○ f)
        (trav_contents (trav_make t v)))) =
forwards (traverse (mkBackwards ○ f) v)
    fequal.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H2: Applicative G
X, A, B: Type
t: T X
f: A -> G B
v: Vector (plength t) A
Hlen: plength (trav_make t v) = plength t
map (coerce_Vector_length Hlen)
  (traverse (mkBackwards ○ f)
     (trav_contents (trav_make t v))) =
traverse (mkBackwards ○ f) v
    apply map_sim_function_traverse_Vector.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H2: Applicative G
X, A, B: Type
t: T X
f: A -> G B
v: Vector (plength t) A
Hlen: plength (trav_make t v) = plength t
trav_contents (trav_make t v) ~~ v
    apply trav_contents_make.
  Qed.

  Lemma mapReduce_opposite_traverse {A}:
    forall `{Monoid M} `{TraversableFunctor T'}
      `{ToBatch T'} `{! Compat_ToBatch_Traverse T'} (t: T' A) (f: A -> M),
      mapReduce (op := Monoid_op_Opposite op) f t =
        forwards (traverse (B := False) (T := T') (G := Backwards (const M)) (mkBackwards ∘ f) t).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
forall (M : Type) (op : Monoid_op M)
  (unit0 : Monoid_unit M),
Monoid M ->
forall (T' : Type -> Type) (Traverse_T : Traverse T'),
TraversableFunctor T' ->
forall H4 : ToBatch T',
Compat_ToBatch_Traverse T' ->
forall (t : T' A) (f : A -> M),
mapReduce f t =
forwards (traverse (mkBackwards ∘ f) t)
  Proof.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
forall (M : Type) (op : Monoid_op M)
  (unit0 : Monoid_unit M),
Monoid M ->
forall (T' : Type -> Type) (Traverse_T : Traverse T'),
TraversableFunctor T' ->
forall H4 : ToBatch T',
Compat_ToBatch_Traverse T' ->
forall (t : T' A) (f : A -> M),
mapReduce f t =
forwards (traverse (mkBackwards ∘ f) t)
    intros.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, M: Type
op: Monoid_op M
unit0: Monoid_unit M
H2: Monoid M
T': Type -> Type
Traverse_T: Traverse T'
H3: TraversableFunctor T'
H4: ToBatch T'
Compat_ToBatch_Traverse1: Compat_ToBatch_Traverse T'
t: T' A
f: A -> M
mapReduce f t =
forwards (traverse (mkBackwards ∘ f) t)
    rewrite mapReduce_to_traverse1.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, M: Type
op: Monoid_op M
unit0: Monoid_unit M
H2: Monoid M
T': Type -> Type
Traverse_T: Traverse T'
H3: TraversableFunctor T'
H4: ToBatch T'
Compat_ToBatch_Traverse1: Compat_ToBatch_Traverse T'
t: T' A
f: A -> M
traverse f t = forwards (traverse (mkBackwards ∘ f) t)
    rewrite traverse_through_runBatch.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, M: Type
op: Monoid_op M
unit0: Monoid_unit M
H2: Monoid M
T': Type -> Type
Traverse_T: Traverse T'
H3: TraversableFunctor T'
H4: ToBatch T'
Compat_ToBatch_Traverse1: Compat_ToBatch_Traverse T'
t: T' A
f: A -> M
(runBatch f ∘ toBatch) t =
forwards (traverse (mkBackwards ∘ f) t)
    rewrite traverse_through_runBatch.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, M: Type
op: Monoid_op M
unit0: Monoid_unit M
H2: Monoid M
T': Type -> Type
Traverse_T: Traverse T'
H3: TraversableFunctor T'
H4: ToBatch T'
Compat_ToBatch_Traverse1: Compat_ToBatch_Traverse T'
t: T' A
f: A -> M
(runBatch f ∘ toBatch) t =
forwards ((runBatch (mkBackwards ∘ f) ∘ toBatch) t)
    unfold compose.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, M: Type
op: Monoid_op M
unit0: Monoid_unit M
H2: Monoid M
T': Type -> Type
Traverse_T: Traverse T'
H3: TraversableFunctor T'
H4: ToBatch T'
Compat_ToBatch_Traverse1: Compat_ToBatch_Traverse T'
t: T' A
f: A -> M
runBatch f (toBatch t) =
forwards (runBatch (mkBackwards ○ f) (toBatch t))
    induction (@toBatch T' _ A False t).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, M: Type
op: Monoid_op M
unit0: Monoid_unit M
H2: Monoid M
T': Type -> Type
Traverse_T: Traverse T'
H3: TraversableFunctor T'
H4: ToBatch T'
Compat_ToBatch_Traverse1: Compat_ToBatch_Traverse T'
t: T' A
f: A -> M
C: Type
c: C
runBatch f (Done c) =
forwards (runBatch (mkBackwards ○ f) (Done c))
T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, M: Type
op: Monoid_op M
unit0: Monoid_unit M
H2: Monoid M
T': Type -> Type
Traverse_T: Traverse T'
H3: TraversableFunctor T'
H4: ToBatch T'
Compat_ToBatch_Traverse1: Compat_ToBatch_Traverse T'
t: T' A
f: A -> M
C: Type
b: Batch A False (False -> C)
a: A
IHb: runBatch f b =
forwards (runBatch (mkBackwards ○ f) b)
runBatch f (b ⧆ a) =
forwards (runBatch (mkBackwards ○ f) (b ⧆ a))
    -T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, M: Type
op: Monoid_op M
unit0: Monoid_unit M
H2: Monoid M
T': Type -> Type
Traverse_T: Traverse T'
H3: TraversableFunctor T'
H4: ToBatch T'
Compat_ToBatch_Traverse1: Compat_ToBatch_Traverse T'
t: T' A
f: A -> M
C: Type
c: C
runBatch f (Done c) =
forwards (runBatch (mkBackwards ○ f) (Done c)) reflexivity.
    -T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, M: Type
op: Monoid_op M
unit0: Monoid_unit M
H2: Monoid M
T': Type -> Type
Traverse_T: Traverse T'
H3: TraversableFunctor T'
H4: ToBatch T'
Compat_ToBatch_Traverse1: Compat_ToBatch_Traverse T'
t: T' A
f: A -> M
C: Type
b: Batch A False (False -> C)
a: A
IHb: runBatch f b =
forwards (runBatch (mkBackwards ○ f) b)
runBatch f (b ⧆ a) =
forwards (runBatch (mkBackwards ○ f) (b ⧆ a)) rewrite runBatch_rw2.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, M: Type
op: Monoid_op M
unit0: Monoid_unit M
H2: Monoid M
T': Type -> Type
Traverse_T: Traverse T'
H3: TraversableFunctor T'
H4: ToBatch T'
Compat_ToBatch_Traverse1: Compat_ToBatch_Traverse T'
t: T' A
f: A -> M
C: Type
b: Batch A False (False -> C)
a: A
IHb: runBatch f b =
forwards (runBatch (mkBackwards ○ f) b)
runBatch f b <⋆> f a =
forwards (runBatch (mkBackwards ○ f) (b ⧆ a))
      rewrite IHb.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, M: Type
op: Monoid_op M
unit0: Monoid_unit M
H2: Monoid M
T': Type -> Type
Traverse_T: Traverse T'
H3: TraversableFunctor T'
H4: ToBatch T'
Compat_ToBatch_Traverse1: Compat_ToBatch_Traverse T'
t: T' A
f: A -> M
C: Type
b: Batch A False (False -> C)
a: A
IHb: runBatch f b =
forwards (runBatch (mkBackwards ○ f) b)
forwards (runBatch (mkBackwards ○ f) b) <⋆> f a =
forwards (runBatch (mkBackwards ○ f) (b ⧆ a))
      rewrite runBatch_rw2.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, M: Type
op: Monoid_op M
unit0: Monoid_unit M
H2: Monoid M
T': Type -> Type
Traverse_T: Traverse T'
H3: TraversableFunctor T'
H4: ToBatch T'
Compat_ToBatch_Traverse1: Compat_ToBatch_Traverse T'
t: T' A
f: A -> M
C: Type
b: Batch A False (False -> C)
a: A
IHb: runBatch f b =
forwards (runBatch (mkBackwards ○ f) b)
forwards (runBatch (mkBackwards ○ f) b) <⋆> f a =
forwards
  (runBatch (mkBackwards ○ f) b <⋆>
   {| forwards := f a |})
      reflexivity.
  Qed.

  Corollary mapReduce_trav_make:
    forall `{Monoid M} (X A: Type)
      (t: T X) (f: A -> M) (v: Vector (plength t) A),
      mapReduce (T := T) f (trav_make t v) =
        mapReduce (op := Monoid_op_Opposite op) f v.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (M : Type) (op : Monoid_op M)
  (unit0 : Monoid_unit M),
Monoid M ->
forall (X A : Type) (t : T X) (f : A -> M)
  (v : Vector (plength t) A),
mapReduce f (trav_make t v) = mapReduce f v
  Proof.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (M : Type) (op : Monoid_op M)
  (unit0 : Monoid_unit M),
Monoid M ->
forall (X A : Type) (t : T X) (f : A -> M)
  (v : Vector (plength t) A),
mapReduce f (trav_make t v) = mapReduce f v
    intros.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
M: Type
op: Monoid_op M
unit0: Monoid_unit M
H2: Monoid M
X, A: Type
t: T X
f: A -> M
v: Vector (plength t) A
mapReduce f (trav_make t v) = mapReduce f v
    unfold mapReduce.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
M: Type
op: Monoid_op M
unit0: Monoid_unit M
H2: Monoid M
X, A: Type
t: T X
f: A -> M
v: Vector (plength t) A
traverse f (trav_make t v) = traverse f v
    rewrite traverse_trav_make.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
M: Type
op: Monoid_op M
unit0: Monoid_unit M
H2: Monoid M
X, A: Type
t: T X
f: A -> M
v: Vector (plength t) A
map (trav_make t)
  (forwards (traverse (mkBackwards ∘ f) v)) =
traverse f v
    unfold_ops @Map_const.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
M: Type
op: Monoid_op M
unit0: Monoid_unit M
H2: Monoid M
X, A: Type
t: T X
f: A -> M
v: Vector (plength t) A
forwards (traverse (mkBackwards ∘ f) v) = traverse f v
    setoid_rewrite <- (mapReduce_opposite_traverse (T' := Vector (plength t))).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
M: Type
op: Monoid_op M
unit0: Monoid_unit M
H2: Monoid M
X, A: Type
t: T X
f: A -> M
v: Vector (plength t) A
mapReduce f v = traverse f v
    reflexivity.
  Qed.

  (** ** Corollary: Specs for Functor Operations in Terms of Lens Operations *)
  (********************************************************************)
  Lemma id_spec:
    forall (A: Type) (t: T A),
      id t = trav_make t (trav_contents t).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A : Type) (t : T A),
id t = trav_make t (trav_contents t)
  Proof.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A : Type) (t : T A),
id t = trav_make t (trav_contents t)
    intros.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
id t = trav_make t (trav_contents t)
    rewrite trav_get_put.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
id t = t
    reflexivity.
  Qed.

  Lemma map_spec:
    forall (A B: Type) (t: T A) (f: A -> B),
      map f t = trav_make t (map f (trav_contents t)).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A B : Type) (t : T A) (f : A -> B),
map f t = trav_make t (map f (trav_contents t))
  Proof.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A B : Type) (t : T A) (f : A -> B),
map f t = trav_make t (map f (trav_contents t))
    intros A B t f.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
f: A -> B
map f t = trav_make t (map f (trav_contents t))
    rewrite <- trav_get_put at 1.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
f: A -> B
trav_make (map f t) (trav_contents (map f t)) =
trav_make t (map f (trav_contents t))
    apply Vector_fun_sim_eq.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
f: A -> B
trav_make (map f t) ~!~ trav_make t
T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
f: A -> B
trav_contents (map f t) ~~ map f (trav_contents t)
    -T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
f: A -> B
trav_make (map f t) ~!~ trav_make t apply trav_same_shape.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
f: A -> B
shape (map f t) = shape t
      rewrite shape_map.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
f: A -> B
shape t = shape t
      reflexivity.
    -T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
f: A -> B
trav_contents (map f t) ~~ map f (trav_contents t) apply trav_contents_natural.
  Qed.

  (** ** Corollary: Specification for <<shape>> *)
  (********************************************************************)
  Lemma trav_contents_shape:
    forall (A: Type) (t: T A),
      trav_contents (shape t) ~~ Vector_tt (plength t).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A : Type) (t : T A),
trav_contents (shape t) ~~ Vector_tt (plength t)
  Proof.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A : Type) (t : T A),
trav_contents (shape t) ~~ Vector_tt (plength t)
    intros.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
trav_contents (shape t) ~~ Vector_tt (plength t)
    (* LHS *)
    unfold trav_contents.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
coerce plength_eq_length (shape t)
in Batch_contents (toBatch (shape t)) ~~
Vector_tt (plength t)
    apply Vector_coerce_sim_l'.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
Batch_contents (toBatch (shape t)) ~~
Vector_tt (plength t)
    unfold shape.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
Batch_contents (toBatch (map (const tt) t)) ~~
Vector_tt (plength t)
    replace (toBatch (A' := False) (map (const tt) t))
      with (mapfst_Batch (B := False) (const tt) (toBatch t)).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
Batch_contents (mapfst_Batch (const tt) (toBatch t)) ~~
Vector_tt (plength t)
T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
mapfst_Batch (const tt) (toBatch t) =
toBatch (map (const tt) t)
    2:{T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
mapfst_Batch (const tt) (toBatch t) =
toBatch (map (const tt) t) compose near t.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
(mapfst_Batch (const tt) ∘ toBatch) t =
(toBatch ∘ map (const tt)) t
        now rewrite toBatch_mapfst. }T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
Batch_contents (mapfst_Batch (const tt) (toBatch t)) ~~
Vector_tt (plength t)
    unfold Vector_tt.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
Batch_contents (mapfst_Batch (const tt) (toBatch t)) ~~
Vector_repeat (plength t) tt
    unfold plength.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
Batch_contents (mapfst_Batch (const tt) (toBatch t)) ~~
Vector_repeat (mapReduce (fun _ : A => 1) t) tt
    rewrite mapReduce_through_runBatch1.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
Batch_contents (mapfst_Batch (const tt) (toBatch t)) ~~
Vector_repeat
  ((runBatch (fun _ : A => 1) ∘ toBatch) t) tt
    unfold compose.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
Batch_contents (mapfst_Batch (const tt) (toBatch t)) ~~
Vector_repeat (runBatch (fun _ : A => 1) (toBatch t))
  tt
    induction (toBatch t).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
C: Type
c: C
Batch_contents (mapfst_Batch (const tt) (Done c)) ~~
Vector_repeat (runBatch (fun _ : A => 1) (Done c)) tt
T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
C: Type
b: Batch A False (False -> C)
a: A
IHb: Batch_contents (mapfst_Batch (const tt) b) ~~
Vector_repeat (runBatch (fun _ : A => 1) b) tt
Batch_contents (mapfst_Batch (const tt) (b ⧆ a)) ~~
Vector_repeat (runBatch (fun _ : A => 1) (b ⧆ a)) tt
    -T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
C: Type
c: C
Batch_contents (mapfst_Batch (const tt) (Done c)) ~~
Vector_repeat (runBatch (fun _ : A => 1) (Done c)) tt reflexivity.
    -T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
C: Type
b: Batch A False (False -> C)
a: A
IHb: Batch_contents (mapfst_Batch (const tt) b) ~~
Vector_repeat (runBatch (fun _ : A => 1) b) tt
Batch_contents (mapfst_Batch (const tt) (b ⧆ a)) ~~
Vector_repeat (runBatch (fun _ : A => 1) (b ⧆ a)) tt cbn.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
C: Type
b: Batch A False (False -> C)
a: A
IHb: Batch_contents (mapfst_Batch (const tt) b) ~~
Vector_repeat (runBatch (fun _ : A => 1) b) tt
vcons (length_Batch (mapfst_Batch (const tt) b))
  (const tt a)
  (Batch_contents (mapfst_Batch (const tt) b)) ~~
Vector_repeat (runBatch (fun _ : A => 1) b ● 1) tt
      unfold_ops @NaturalNumbers.Monoid_op_plus.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
C: Type
b: Batch A False (False -> C)
a: A
IHb: Batch_contents (mapfst_Batch (const tt) b) ~~
Vector_repeat (runBatch (fun _ : A => 1) b) tt
vcons (length_Batch (mapfst_Batch (const tt) b))
  (const tt a)
  (Batch_contents (mapfst_Batch (const tt) b)) ~~
Vector_repeat (runBatch (fun _ : A => 1) b + 1) tt
      rewrite PeanoNat.Nat.add_1_r.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
C: Type
b: Batch A False (False -> C)
a: A
IHb: Batch_contents (mapfst_Batch (const tt) b) ~~
Vector_repeat (runBatch (fun _ : A => 1) b) tt
vcons (length_Batch (mapfst_Batch (const tt) b))
  (const tt a)
  (Batch_contents (mapfst_Batch (const tt) b)) ~~
Vector_repeat (S (runBatch (fun _ : A => 1) b)) tt
      cbn.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
C: Type
b: Batch A False (False -> C)
a: A
IHb: Batch_contents (mapfst_Batch (const tt) b) ~~
Vector_repeat (runBatch (fun _ : A => 1) b) tt
vcons (length_Batch (mapfst_Batch (const tt) b))
  (const tt a)
  (Batch_contents (mapfst_Batch (const tt) b)) ~~
vcons (runBatch (fun _ : A => 1) b) tt
  (Vector_repeat (runBatch (fun _ : A => 1) b) tt)
      apply vcons_sim.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
C: Type
b: Batch A False (False -> C)
a: A
IHb: Batch_contents (mapfst_Batch (const tt) b) ~~
Vector_repeat (runBatch (fun _ : A => 1) b) tt
Batch_contents (mapfst_Batch (const tt) b) ~~
Vector_repeat (runBatch (fun _ : A => 1) b) tt
      assumption.
  Qed.

  Lemma shape_spec:
    forall (A: Type) (t: T A),
      shape t = trav_make (B := unit) t (Vector_tt (plength t)).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A : Type) (t : T A),
shape t = trav_make t (Vector_tt (plength t))
  Proof.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A : Type) (t : T A),
shape t = trav_make t (Vector_tt (plength t))
    intros A t.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
shape t = trav_make t (Vector_tt (plength t))
    unfold shape.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
map (const tt) t = trav_make t (Vector_tt (plength t))
    rewrite map_spec.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
trav_make t (map (const tt) (trav_contents t)) =
trav_make t (Vector_tt (plength t))
    fequal.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
map (const tt) (trav_contents t) =
Vector_tt (plength t)
    apply Vector_sim_eq.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
map (const tt) (trav_contents t) ~~
Vector_tt (plength t)
    unfold Vector_sim.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
proj1_sig (map (const tt) (trav_contents t)) =
proj1_sig (Vector_tt (plength t))
    rewrite <- (trav_contents_natural A unit t (const tt)).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
proj1_sig (trav_contents (map (const tt) t)) =
proj1_sig (Vector_tt (plength t))
    change (map (const tt) t) with (shape t).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
proj1_sig (trav_contents (shape t)) =
proj1_sig (Vector_tt (plength t))
    rewrite trav_contents_shape.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
proj1_sig (Vector_tt (plength t)) =
proj1_sig (Vector_tt (plength t))
    reflexivity.
  Qed.

  Lemma trav_same_shape_rev {A1 A2: Type}
    {t1: T A1} {t2: T A2}:
    (forall B, trav_make (B := B) t1 ~!~ trav_make t2) ->
    shape t1 = shape t2.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2: Type
t1: T A1
t2: T A2
(forall B : Type, trav_make t1 ~!~ trav_make t2) ->
shape t1 = shape t2
  Proof.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2: Type
t1: T A1
t2: T A2
(forall B : Type, trav_make t1 ~!~ trav_make t2) ->
shape t1 = shape t2
    introv Hmake.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2: Type
t1: T A1
t2: T A2
Hmake: forall B : Type, trav_make t1 ~!~ trav_make t2
shape t1 = shape t2
    rewrite shape_spec.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2: Type
t1: T A1
t2: T A2
Hmake: forall B : Type, trav_make t1 ~!~ trav_make t2
trav_make t1 (Vector_tt (plength t1)) = shape t2
    rewrite shape_spec.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2: Type
t1: T A1
t2: T A2
Hmake: forall B : Type, trav_make t1 ~!~ trav_make t2
trav_make t1 (Vector_tt (plength t1)) =
trav_make t2 (Vector_tt (plength t2))
    destruct (Hmake unit) as
      [Hlen Hmake'].T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2: Type
t1: T A1
t2: T A2
Hmake: forall B : Type, trav_make t1 ~!~ trav_make t2
Hlen: plength t1 = plength t2
Hmake': forall (v1 : Vector (plength t1) unit)
  (v2 : Vector (plength t2) unit),
v1 ~~ v2 -> trav_make t1 v1 = trav_make t2 v2
trav_make t1 (Vector_tt (plength t1)) =
trav_make t2 (Vector_tt (plength t2))
    apply Vector_fun_sim_eq.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2: Type
t1: T A1
t2: T A2
Hmake: forall B : Type, trav_make t1 ~!~ trav_make t2
Hlen: plength t1 = plength t2
Hmake': forall (v1 : Vector (plength t1) unit)
  (v2 : Vector (plength t2) unit),
v1 ~~ v2 -> trav_make t1 v1 = trav_make t2 v2
trav_make t1 ~!~ trav_make t2
T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2: Type
t1: T A1
t2: T A2
Hmake: forall B : Type, trav_make t1 ~!~ trav_make t2
Hlen: plength t1 = plength t2
Hmake': forall (v1 : Vector (plength t1) unit)
  (v2 : Vector (plength t2) unit),
v1 ~~ v2 -> trav_make t1 v1 = trav_make t2 v2
Vector_tt (plength t1) ~~ Vector_tt (plength t2)
    -T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2: Type
t1: T A1
t2: T A2
Hmake: forall B : Type, trav_make t1 ~!~ trav_make t2
Hlen: plength t1 = plength t2
Hmake': forall (v1 : Vector (plength t1) unit)
  (v2 : Vector (plength t2) unit),
v1 ~~ v2 -> trav_make t1 v1 = trav_make t2 v2
trav_make t1 ~!~ trav_make t2 apply Hmake.
    -T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2: Type
t1: T A1
t2: T A2
Hmake: forall B : Type, trav_make t1 ~!~ trav_make t2
Hlen: plength t1 = plength t2
Hmake': forall (v1 : Vector (plength t1) unit)
  (v2 : Vector (plength t2) unit),
v1 ~~ v2 -> trav_make t1 v1 = trav_make t2 v2
Vector_tt (plength t1) ~~ Vector_tt (plength t2) now inversion Hlen.
  Qed.

  Lemma trav_same_shape_iff {A1 A2: Type}
    {t1: T A1} {t2: T A2}:
    shape t1 = shape t2 <->
      (forall B, trav_make (B := B) t1 ~!~ trav_make t2).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2: Type
t1: T A1
t2: T A2
shape t1 = shape t2 <->
(forall B : Type, trav_make t1 ~!~ trav_make t2)
  Proof.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2: Type
t1: T A1
t2: T A2
shape t1 = shape t2 <->
(forall B : Type, trav_make t1 ~!~ trav_make t2)
    split.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2: Type
t1: T A1
t2: T A2
shape t1 = shape t2 ->
forall B : Type, trav_make t1 ~!~ trav_make t2
T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2: Type
t1: T A1
t2: T A2
(forall B : Type, trav_make t1 ~!~ trav_make t2) ->
shape t1 = shape t2
    -T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2: Type
t1: T A1
t2: T A2
shape t1 = shape t2 ->
forall B : Type, trav_make t1 ~!~ trav_make t2 apply trav_same_shape.
    -T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2: Type
t1: T A1
t2: T A2
(forall B : Type, trav_make t1 ~!~ trav_make t2) ->
shape t1 = shape t2 apply trav_same_shape_rev.
  Qed.

  Corollary trav_make_sim_map:
    forall `(t: T A)
      `(f: A -> B) (C: Type),
      trav_make (B := C) t ~!~
        (trav_make (B := C) (map (F := T) f t)).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A : Type) (t : T A) (B : Type) (f : A -> B)
  (C : Type), trav_make t ~!~ trav_make (map f t)
  Proof.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A : Type) (t : T A) (B : Type) (f : A -> B)
  (C : Type), trav_make t ~!~ trav_make (map f t)
    intros.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
B: Type
f: A -> B
C: Type
trav_make t ~!~ trav_make (map f t)
    apply trav_same_shape_iff.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
B: Type
f: A -> B
C: Type
shape t = shape (map f t)
    rewrite shape_map.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A: Type
t: T A
B: Type
f: A -> B
C: Type
shape t = shape t
    reflexivity.
  Qed.

  (** ** <<trav_make>> is Preserved by <<shape>> *)
  (********************************************************************)
  Lemma trav_make_shape_spec {A B: Type}: forall (t: T A),
      trav_make (B := B) t ~!~ trav_make (B := B) (shape t).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
forall t : T A, trav_make t ~!~ trav_make (shape t)
  Proof.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
forall t : T A, trav_make t ~!~ trav_make (shape t)
    intros t.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
trav_make t ~!~ trav_make (shape t)
    apply trav_same_shape.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
shape t = shape (shape t)
    rewrite shape_shape.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
shape t = shape t
    reflexivity.
  Qed.

  (** ** <<tosubset>> is Preserved by <<trav_contents>> *)
  (********************************************************************)
  Lemma tosubset_spec `{ToSubset T} `{! Compat_ToSubset_Traverse T}:
    forall (A: Type) (t: T A),
      tosubset t = tosubset (trav_contents t).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
H2: ToSubset T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
forall (A : Type) (t : T A),
tosubset t = tosubset (trav_contents t)
  Proof.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
H2: ToSubset T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
forall (A : Type) (t : T A),
tosubset t = tosubset (trav_contents t)
    intros A t.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
H2: ToSubset T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A: Type
t: T A
tosubset t = tosubset (trav_contents t)
    rewrite tosubset_through_tolist.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
H2: ToSubset T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A: Type
t: T A
(tosubset ∘ tolist) t = tosubset (trav_contents t)
    unfold compose at 1.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
H2: ToSubset T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A: Type
t: T A
tosubset (tolist t) = tosubset (trav_contents t)
    rewrite (tosubset_through_tolist (T := Vector (plength t))).T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
H2: ToSubset T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A: Type
t: T A
tosubset (tolist t) =
(tosubset ∘ tolist) (trav_contents t)
    unfold compose at 1.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
H2: ToSubset T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A: Type
t: T A
tosubset (tolist t) =
tosubset (tolist (trav_contents t))
    rewrite <- Vector_to_list_tolist.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
H2: ToSubset T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A: Type
t: T A
tosubset (tolist t) =
tosubset (Vector_to_list A (trav_contents t))
    rewrite tolist_trav_contents.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
H2: ToSubset T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A: Type
t: T A
tosubset (tolist t) = tosubset (List.rev (tolist t))
    rewrite tosubset_to_mapReduce.T: Type -> Type
H: Traverse T
H0: Map T
H1: ToBatch T
TraversableFunctor0: TraversableFunctor T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
H2: ToSubset T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
A: Type
t: T A
mapReduce ret (tolist t) =
mapReduce ret (List.rev (tolist t))
    apply mapReduce_comm_list.
  Qed.

End deconstruction.

(** * Lemmas about <<shape>> *)
(**********************************************************************)
Section misc.

  Context
    `{Classes.Kleisli.TraversableFunctor.TraversableFunctor T}
    `{ToMap_inst: Map T}
    `{ToSubset_inst: ToSubset T}
    `{ToBatch_inst: ToBatch T}
    `{! Compat_Map_Traverse T}
    `{! Compat_ToSubset_Traverse T}
    `{! Compat_ToBatch_Traverse T}.

    (*
  (** ** Same <<shape>> Implies Same <<trav_make>> *)
  (********************************************************************)
  Lemma same_shape_implies_make_sim:
    forall (A B C: Type) (t: T A) (u: T B),
      shape t = shape u ->
      trav_make (B := C) t ~!~ trav_make u.
  Proof.
    intros. apply trav_same_shape.
    assumption.
    introv Hshape.
    eapply (transitive_Vector_fun_sim).
    apply (trav_make_shape_spec t).
    rewrite Hshape.
    apply symmetric_Vector_fun_sim.
    apply (trav_make_shape_spec u).
  Qed.
   *)

  (** ** Specification for <<id>> given two terms with the same <<shape>> *)
  (********************************************************************)
  Lemma same_shape_implies_other_make:
    forall (A B: Type) (t: T A) (u: T B)
      (Hshape: shape t = shape u),
      t = trav_make u
            (coerce (same_shape_implies_plength t u Hshape)
              in (trav_contents t)).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A B : Type) (t : T A) (u : T B)
  (Hshape : shape t = shape u),
t =
trav_make u
  (coerce same_shape_implies_plength t u Hshape
   in trav_contents t)
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A B : Type) (t : T A) (u : T B)
  (Hshape : shape t = shape u),
t =
trav_make u
  (coerce same_shape_implies_plength t u Hshape
   in trav_contents t)
    intros.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape: shape t = shape u
t =
trav_make u
  (coerce same_shape_implies_plength t u Hshape
   in trav_contents t)
    change t with (id t) at 1.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape: shape t = shape u
id t =
trav_make u
  (coerce same_shape_implies_plength t u Hshape
   in trav_contents t)
    rewrite id_spec.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape: shape t = shape u
trav_make t (trav_contents t) =
trav_make u
  (coerce same_shape_implies_plength t u Hshape
   in trav_contents t)
    pose (cut := trav_same_shape Hshape A).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape: shape t = shape u
cut:= trav_same_shape Hshape A: trav_make t ~!~ trav_make u
trav_make t (trav_contents t) =
trav_make u
  (coerce same_shape_implies_plength t u Hshape
   in trav_contents t)
    destruct cut as [Hlen H_make_eq].T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape: shape t = shape u
Hlen: plength t = plength u
H_make_eq: forall (v1 : Vector (plength t) A)
  (v2 : Vector (plength u) A),
v1 ~~ v2 ->
trav_make t v1 = trav_make u v2
trav_make t (trav_contents t) =
trav_make u
  (coerce same_shape_implies_plength t u Hshape
   in trav_contents t)
    apply H_make_eq.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape: shape t = shape u
Hlen: plength t = plength u
H_make_eq: forall (v1 : Vector (plength t) A)
  (v2 : Vector (plength u) A),
v1 ~~ v2 ->
trav_make t v1 = trav_make u v2
trav_contents t ~~
coerce same_shape_implies_plength t u Hshape
in trav_contents t
    vector_sim.
  Qed.

End misc.

(** * Zipping Terms *)
(**********************************************************************)
From Tealeaves Require Import Functors.Pair.

Section traversable_functors_zipping.

  Context
    `{Classes.Kleisli.TraversableFunctor.TraversableFunctor T}
    `{ToMap_inst: Map T}
    `{ToSubset_inst: ToSubset T}
    `{ToBatch_inst: ToBatch T}
    `{! Compat_Map_Traverse T}
    `{! Compat_ToSubset_Traverse T}
    `{! Compat_ToBatch_Traverse T}.

  (** ** Operation to Zip Contents of Same-<<shape>> Terms *)
  (********************************************************************)
  Definition same_shape_zip_contents
    (A B: Type) (t: T A) (u: T B)
      (Hshape: shape t = shape u):
    Vector (plength t) (A * B) :=
      Vector_zip A B (plength t) (plength u) (trav_contents t) (trav_contents u)
        (same_shape_implies_plength t u Hshape).

  #[global] Arguments same_shape_zip_contents {A B}%type_scope t u Hshape.

  (** ** Proof Irrelevance *)
  (********************************************************************)
  Lemma same_shape_zip_contents_proof_irrelevance:
    forall (A B: Type) (t: T A) (u: T B)
      (Hshape1: shape t = shape u)
      (Hshape2: shape t = shape u),
      same_shape_zip_contents t u Hshape1 =
        same_shape_zip_contents t u Hshape2.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A B : Type) (t : T A) (u : T B)
  (Hshape1 Hshape2 : shape t = shape u),
same_shape_zip_contents t u Hshape1 =
same_shape_zip_contents t u Hshape2
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A B : Type) (t : T A) (u : T B)
  (Hshape1 Hshape2 : shape t = shape u),
same_shape_zip_contents t u Hshape1 =
same_shape_zip_contents t u Hshape2
    intros.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape1, Hshape2: shape t = shape u
same_shape_zip_contents t u Hshape1 =
same_shape_zip_contents t u Hshape2
    unfold same_shape_zip_contents.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape1, Hshape2: shape t = shape u
Vector_zip A B (plength t) (plength u)
  (trav_contents t) (trav_contents u)
  (same_shape_implies_plength t u Hshape1) =
Vector_zip A B (plength t) (plength u)
  (trav_contents t) (trav_contents u)
  (same_shape_implies_plength t u Hshape2)
    fequal.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape1, Hshape2: shape t = shape u
same_shape_implies_plength t u Hshape1 =
same_shape_implies_plength t u Hshape2
    apply proof_irrelevance.
  Qed.

  (* useful when <<u>> can't be rewritten due to Hshape proofs *)
  Lemma same_shape_zip_contents_proof_irrelevance2:
    forall (A B: Type)
      (t: T A) (u: T B) (u': T B)
      (Hshape1: shape t = shape u)
      (Hshape2: shape t = shape u'),
      u = u' ->
      same_shape_zip_contents t u Hshape1 =
        same_shape_zip_contents t u' Hshape2.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A B : Type) (t : T A) (u u' : T B)
  (Hshape1 : shape t = shape u)
  (Hshape2 : shape t = shape u'),
u = u' ->
same_shape_zip_contents t u Hshape1 =
same_shape_zip_contents t u' Hshape2
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A B : Type) (t : T A) (u u' : T B)
  (Hshape1 : shape t = shape u)
  (Hshape2 : shape t = shape u'),
u = u' ->
same_shape_zip_contents t u Hshape1 =
same_shape_zip_contents t u' Hshape2
    introv Heq.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u, u': T B
Hshape1: shape t = shape u
Hshape2: shape t = shape u'
Heq: u = u'
same_shape_zip_contents t u Hshape1 =
same_shape_zip_contents t u' Hshape2
    subst.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u': T B
Hshape1, Hshape2: shape t = shape u'
same_shape_zip_contents t u' Hshape1 =
same_shape_zip_contents t u' Hshape2
    apply same_shape_zip_contents_proof_irrelevance.
  Qed.

  (* useful when <<u>> can't be rewritten due to Hshape proofs *)
  Lemma same_shape_zip_contents_proof_irrelevance3:
    forall (A B: Type)
      (t: T A) (t': T A) (u: T B) (u': T B)
      (Hshape1: shape t = shape u)
      (Hshape2: shape t' = shape u'),
      t = t' ->
      u = u' ->
      (same_shape_zip_contents t u Hshape1 ~~
        same_shape_zip_contents t' u' Hshape2).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A B : Type) (t t' : T A) (u u' : T B)
  (Hshape1 : shape t = shape u)
  (Hshape2 : shape t' = shape u'),
t = t' ->
u = u' ->
same_shape_zip_contents t u Hshape1 ~~
same_shape_zip_contents t' u' Hshape2
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A B : Type) (t t' : T A) (u u' : T B)
  (Hshape1 : shape t = shape u)
  (Hshape2 : shape t' = shape u'),
t = t' ->
u = u' ->
same_shape_zip_contents t u Hshape1 ~~
same_shape_zip_contents t' u' Hshape2
    introv Heqt Hequ.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t, t': T A
u, u': T B
Hshape1: shape t = shape u
Hshape2: shape t' = shape u'
Heqt: t = t'
Hequ: u = u'
same_shape_zip_contents t u Hshape1 ~~
same_shape_zip_contents t' u' Hshape2
    subst.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t': T A
u': T B
Hshape1, Hshape2: shape t' = shape u'
same_shape_zip_contents t' u' Hshape1 ~~
same_shape_zip_contents t' u' Hshape2
    erewrite same_shape_zip_contents_proof_irrelevance.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t': T A
u': T B
Hshape1, Hshape2: shape t' = shape u'
same_shape_zip_contents t' u' ?Hshape2 ~~
same_shape_zip_contents t' u' Hshape2
    reflexivity.
  Qed.

  (** ** Roundtrip Properties *)
  (********************************************************************)
  Lemma same_shape_zip_contents_fst
    (A B: Type) (t: T A) (u: T B)
    (Hshape: shape t = shape u):
    map fst (same_shape_zip_contents t u Hshape) = trav_contents t.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape: shape t = shape u
map fst (same_shape_zip_contents t u Hshape) =
trav_contents t
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape: shape t = shape u
map fst (same_shape_zip_contents t u Hshape) =
trav_contents t
    unfold same_shape_zip_contents.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape: shape t = shape u
map fst
  (Vector_zip A B (plength t) (plength u)
     (trav_contents t) (trav_contents u)
     (same_shape_implies_plength t u Hshape)) =
trav_contents t
    rewrite Vector_zip_fst.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape: shape t = shape u
trav_contents t = trav_contents t
    reflexivity.
  Qed.

  Lemma same_shape_zip_contents_snd
    (A B: Type) (t: T A) (u: T B)
    (Hshape: shape t = shape u):
    map snd (same_shape_zip_contents t u Hshape) ~~ trav_contents u.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape: shape t = shape u
map snd (same_shape_zip_contents t u Hshape) ~~
trav_contents u
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape: shape t = shape u
map snd (same_shape_zip_contents t u Hshape) ~~
trav_contents u
    unfold same_shape_zip_contents.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape: shape t = shape u
map snd
  (Vector_zip A B (plength t) (plength u)
     (trav_contents t) (trav_contents u)
     (same_shape_implies_plength t u Hshape)) ~~
trav_contents u
    apply (Vector_zip_snd A B
            (plength t) (plength u)
            (trav_contents t) (trav_contents u)
            (same_shape_implies_plength t u Hshape)).
  Qed.

  (** ** Naturality Properties *)
  (********************************************************************)
  Lemma same_shape_map {A1 A2 B1 B2}:
    forall (t: T A1) (u: T B1) (Hshape: shape t = shape u)
      (f: A1 -> A2) (g: B1 -> B2),
      shape (map f t) = shape (map g u).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
forall (t : T A1) (u : T B1),
shape t = shape u ->
forall (f : A1 -> A2) (g : B1 -> B2),
shape (map f t) = shape (map g u)
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
forall (t : T A1) (u : T B1),
shape t = shape u ->
forall (f : A1 -> A2) (g : B1 -> B2),
shape (map f t) = shape (map g u)
    intros.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
Hshape: shape t = shape u
f: A1 -> A2
g: B1 -> B2
shape (map f t) = shape (map g u)
    rewrite (shape_map).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
Hshape: shape t = shape u
f: A1 -> A2
g: B1 -> B2
shape t = shape (map g u)
    rewrite (shape_map).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
Hshape: shape t = shape u
f: A1 -> A2
g: B1 -> B2
shape t = shape u
    assumption.
  Qed.

  Lemma same_shape_map_l {A1 A2 B}:
    forall (t: T A1) (u: T B) (Hshape: shape t = shape u)
      (f: A1 -> A2),
      shape (map f t) = shape u.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
forall (t : T A1) (u : T B),
shape t = shape u ->
forall f : A1 -> A2, shape (map f t) = shape u
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
forall (t : T A1) (u : T B),
shape t = shape u ->
forall f : A1 -> A2, shape (map f t) = shape u
    intros.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
t: T A1
u: T B
Hshape: shape t = shape u
f: A1 -> A2
shape (map f t) = shape u
    rewrite (shape_map).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
t: T A1
u: T B
Hshape: shape t = shape u
f: A1 -> A2
shape t = shape u
    assumption.
  Qed.

  Lemma same_shape_map_r {A B1 B2}:
    forall (t: T A) (u: T B1) (Hshape: shape t = shape u)
      (g: B1 -> B2),
      shape t = shape (map g u).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
forall (t : T A) (u : T B1),
shape t = shape u ->
forall g : B1 -> B2, shape t = shape (map g u)
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
forall (t : T A) (u : T B1),
shape t = shape u ->
forall g : B1 -> B2, shape t = shape (map g u)
    intros.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
t: T A
u: T B1
Hshape: shape t = shape u
g: B1 -> B2
shape t = shape (map g u)
    rewrite (shape_map).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
t: T A
u: T B1
Hshape: shape t = shape u
g: B1 -> B2
shape t = shape u
    assumption.
  Qed.

  Lemma same_shape_map_rev {A1 A2 B1 B2}:
    forall (t: T A1) (u: T B1)
      (f: A1 -> A2) (g: B1 -> B2)
      (Hshape: shape (map f t) = shape (map g u)),
      shape t = shape u.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
forall (t : T A1) (u : T B1) (f : A1 -> A2)
  (g : B1 -> B2),
shape (map f t) = shape (map g u) -> shape t = shape u
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
forall (t : T A1) (u : T B1) (f : A1 -> A2)
  (g : B1 -> B2),
shape (map f t) = shape (map g u) -> shape t = shape u
    introv.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
f: A1 -> A2
g: B1 -> B2
shape (map f t) = shape (map g u) -> shape t = shape u
    rewrite (shape_map).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
f: A1 -> A2
g: B1 -> B2
shape t = shape (map g u) -> shape t = shape u
    rewrite (shape_map).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
f: A1 -> A2
g: B1 -> B2
shape t = shape u -> shape t = shape u
    easy.
  Qed.

  Lemma same_shape_map_rev_l {A1 A2 B}:
    forall (t: T A1) (u: T B)
      (f: A1 -> A2)
      (Hshape: shape (map f t) = shape u),
      shape t = shape u.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
forall (t : T A1) (u : T B) (f : A1 -> A2),
shape (map f t) = shape u -> shape t = shape u
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
forall (t : T A1) (u : T B) (f : A1 -> A2),
shape (map f t) = shape u -> shape t = shape u
    introv.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
t: T A1
u: T B
f: A1 -> A2
shape (map f t) = shape u -> shape t = shape u
    rewrite (shape_map).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
t: T A1
u: T B
f: A1 -> A2
shape t = shape u -> shape t = shape u
    easy.
  Qed.

  Lemma same_shape_map_rev_r {A B1 B2}:
    forall (t: T A) (u: T B1)
      (g: B1 -> B2)
      (Hshape: shape t = shape (map g u)),
      shape t = shape u.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
forall (t : T A) (u : T B1) (g : B1 -> B2),
shape t = shape (map g u) -> shape t = shape u
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
forall (t : T A) (u : T B1) (g : B1 -> B2),
shape t = shape (map g u) -> shape t = shape u
    introv.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
t: T A
u: T B1
g: B1 -> B2
shape t = shape (map g u) -> shape t = shape u
    rewrite (shape_map).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
t: T A
u: T B1
g: B1 -> B2
shape t = shape u -> shape t = shape u
    easy.
  Qed.

  Lemma natural_same_shape_zip_contents
    {A1 A2 B1 B2: Type}:
    forall (t: T A1) (u: T B1) (Hshape: shape t = shape u)
      (f: A1 -> A2) (g: B1 -> B2),
      map (map_pair f g) (same_shape_zip_contents t u Hshape)=
        coerce (natural_plength f t) in
      same_shape_zip_contents (map f t) (map g u) (same_shape_map t u Hshape _ _).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
forall (t : T A1) (u : T B1)
  (Hshape : shape t = shape u) (f : A1 -> A2)
  (g : B1 -> B2),
map (map_pair f g)
  (same_shape_zip_contents t u Hshape) =
coerce natural_plength f t
in same_shape_zip_contents (map f t) (map g u)
     (same_shape_map t u Hshape f g)
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
forall (t : T A1) (u : T B1)
  (Hshape : shape t = shape u) (f : A1 -> A2)
  (g : B1 -> B2),
map (map_pair f g)
  (same_shape_zip_contents t u Hshape) =
coerce natural_plength f t
in same_shape_zip_contents (map f t) (map g u)
     (same_shape_map t u Hshape f g)
    intros.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
Hshape: shape t = shape u
f: A1 -> A2
g: B1 -> B2
map (map_pair f g)
  (same_shape_zip_contents t u Hshape) =
coerce natural_plength f t
in same_shape_zip_contents (map f t) (map g u)
     (same_shape_map t u Hshape f g)
    apply Vector_sim_eq.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
Hshape: shape t = shape u
f: A1 -> A2
g: B1 -> B2
map (map_pair f g)
  (same_shape_zip_contents t u Hshape) ~~
coerce natural_plength f t
in same_shape_zip_contents (map f t) (map g u)
     (same_shape_map t u Hshape f g)
    vector_sim.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
Hshape: shape t = shape u
f: A1 -> A2
g: B1 -> B2
map (map_pair f g)
  (same_shape_zip_contents t u Hshape) ~~
same_shape_zip_contents (map f t) (map g u)
  (same_shape_map t u Hshape f g)
    unfold same_shape_zip_contents.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
Hshape: shape t = shape u
f: A1 -> A2
g: B1 -> B2
map (map_pair f g)
  (Vector_zip A1 B1 (plength t) (plength u)
     (trav_contents t) (trav_contents u)
     (same_shape_implies_plength t u Hshape)) ~~
Vector_zip A2 B2 (plength (map f t))
  (plength (map g u)) (trav_contents (map f t))
  (trav_contents (map g u))
  (same_shape_implies_plength (map f t) (map g u)
     (same_shape_map t u Hshape f g))
    unfold Vector_zip.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
Hshape: shape t = shape u
f: A1 -> A2
g: B1 -> B2
map (map_pair f g)
  (Vector_zip_eq (trav_contents t)
     (coerce eq_sym
               (same_shape_implies_plength t u Hshape)
      in trav_contents u)) ~~
Vector_zip_eq (trav_contents (map f t))
  (coerce eq_sym
            (same_shape_implies_plength (map f t)
               (map g u)
               (same_shape_map t u Hshape f g))
   in trav_contents (map g u))
    rewrite natural_Vector_zip_eq.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
Hshape: shape t = shape u
f: A1 -> A2
g: B1 -> B2
Vector_zip_eq (map f (trav_contents t))
  (map g
     (coerce eq_sym
               (same_shape_implies_plength t u Hshape)
      in trav_contents u)) ~~
Vector_zip_eq (trav_contents (map f t))
  (coerce eq_sym
            (same_shape_implies_plength (map f t)
               (map g u)
               (same_shape_map t u Hshape f g))
   in trav_contents (map g u))
    apply Vector_zip_eq_sim_poly_both.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
Hshape: shape t = shape u
f: A1 -> A2
g: B1 -> B2
map f (trav_contents t) ~~ trav_contents (map f t)
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
Hshape: shape t = shape u
f: A1 -> A2
g: B1 -> B2
map g
  (coerce eq_sym
            (same_shape_implies_plength t u Hshape)
   in trav_contents u) ~~
coerce eq_sym
         (same_shape_implies_plength 
            (map f t) 
            (map g u) 
            (same_shape_map t u Hshape f g))
in trav_contents (map g u)
    -T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
Hshape: shape t = shape u
f: A1 -> A2
g: B1 -> B2
map f (trav_contents t) ~~ trav_contents (map f t) apply symmetric_Vector_sim.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
Hshape: shape t = shape u
f: A1 -> A2
g: B1 -> B2
trav_contents (map f t) ~~ map f (trav_contents t)
      apply trav_contents_natural.
    -T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
Hshape: shape t = shape u
f: A1 -> A2
g: B1 -> B2
map g
  (coerce eq_sym
            (same_shape_implies_plength t u Hshape)
   in trav_contents u) ~~
coerce eq_sym
         (same_shape_implies_plength (map f t)
            (map g u) (same_shape_map t u Hshape f g))
in trav_contents (map g u) vector_sim.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
Hshape: shape t = shape u
f: A1 -> A2
g: B1 -> B2
map g (trav_contents u) ~~ trav_contents (map g u)
      apply symmetric_Vector_sim.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
Hshape: shape t = shape u
f: A1 -> A2
g: B1 -> B2
trav_contents (map g u) ~~ map g (trav_contents u)
      apply trav_contents_natural.
  Qed.

  Lemma natural_same_shape_zip_contents_op
    {A1 A2 B1 B2: Type}:
    forall (t: T A1) (u: T B1)
      (f: A1 -> A2) (g: B1 -> B2)
      (Hshape: shape (map f t) = shape (map g u)),
      same_shape_zip_contents (map f t) (map g u) Hshape =
        coerce (eq_sym (natural_plength f t)) in
      map (map_pair f g) (same_shape_zip_contents t u (same_shape_map_rev t u _ _ Hshape)).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
forall (t : T A1) (u : T B1) (f : A1 -> A2)
  (g : B1 -> B2)
  (Hshape : shape (map f t) = shape (map g u)),
same_shape_zip_contents (map f t) (map g u) Hshape =
coerce eq_sym (natural_plength f t)
in map (map_pair f g)
     (same_shape_zip_contents t u
        (same_shape_map_rev t u f g Hshape))
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
forall (t : T A1) (u : T B1) (f : A1 -> A2)
  (g : B1 -> B2)
  (Hshape : shape (map f t) = shape (map g u)),
same_shape_zip_contents (map f t) (map g u) Hshape =
coerce eq_sym (natural_plength f t)
in map (map_pair f g)
     (same_shape_zip_contents t u
        (same_shape_map_rev t u f g Hshape))
    intros.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
f: A1 -> A2
g: B1 -> B2
Hshape: shape (map f t) = shape (map g u)
same_shape_zip_contents (map f t) (map g u) Hshape =
coerce eq_sym (natural_plength f t)
in map (map_pair f g)
     (same_shape_zip_contents t u
        (same_shape_map_rev t u f g Hshape))
    rewrite natural_same_shape_zip_contents.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
f: A1 -> A2
g: B1 -> B2
Hshape: shape (map f t) = shape (map g u)
same_shape_zip_contents (map f t) (map g u) Hshape =
coerce eq_sym (natural_plength f t)
in coerce natural_plength f t
   in same_shape_zip_contents (map f t) (map g u)
        (same_shape_map t u
           (same_shape_map_rev t u f g Hshape) f g)
    apply Vector_sim_eq.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
f: A1 -> A2
g: B1 -> B2
Hshape: shape (map f t) = shape (map g u)
same_shape_zip_contents (map f t) (map g u) Hshape ~~
coerce eq_sym (natural_plength f t)
in coerce natural_plength f t
   in same_shape_zip_contents (map f t) (map g u)
        (same_shape_map t u
           (same_shape_map_rev t u f g Hshape) f g)
    vector_sim.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
f: A1 -> A2
g: B1 -> B2
Hshape: shape (map f t) = shape (map g u)
same_shape_zip_contents (map f t) (map g u) Hshape ~~
same_shape_zip_contents (map f t) (map g u)
  (same_shape_map t u
     (same_shape_map_rev t u f g Hshape) f g)
    vector_sim.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
f: A1 -> A2
g: B1 -> B2
Hshape: shape (map f t) = shape (map g u)
same_shape_zip_contents (map f t) (map g u) Hshape ~~
same_shape_zip_contents (map f t) (map g u)
  (same_shape_map t u
     (same_shape_map_rev t u f g Hshape) f g)
    fequal.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
f: A1 -> A2
g: B1 -> B2
Hshape: shape (map f t) = shape (map g u)
same_shape_zip_contents (map f t) (map g u) Hshape =
same_shape_zip_contents (map f t) (map g u)
  (same_shape_map t u
     (same_shape_map_rev t u f g Hshape) f g)
    fequal.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
f: A1 -> A2
g: B1 -> B2
Hshape: shape (map f t) = shape (map g u)
Hshape =
same_shape_map t u (same_shape_map_rev t u f g Hshape)
  f g
    apply proof_irrelevance.
  Qed.

  Corollary natural_fst_same_shape_zip_contents
    {A1 A2 B: Type}:
    forall (t: T A1) (u: T B) (Hshape: shape t = shape u)
      (f: A1 -> A2),
      map (map_fst f) (same_shape_zip_contents t u Hshape) =
        coerce (natural_plength f t) in
      same_shape_zip_contents (map f t) u (same_shape_map_l t u Hshape f).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
forall (t : T A1) (u : T B)
  (Hshape : shape t = shape u) (f : A1 -> A2),
map (map_fst f) (same_shape_zip_contents t u Hshape) =
coerce natural_plength f t
in same_shape_zip_contents (map f t) u
     (same_shape_map_l t u Hshape f)
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
forall (t : T A1) (u : T B)
  (Hshape : shape t = shape u) (f : A1 -> A2),
map (map_fst f) (same_shape_zip_contents t u Hshape) =
coerce natural_plength f t
in same_shape_zip_contents (map f t) u
     (same_shape_map_l t u Hshape f)
    intros.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
t: T A1
u: T B
Hshape: shape t = shape u
f: A1 -> A2
map (map_fst f) (same_shape_zip_contents t u Hshape) =
coerce natural_plength f t
in same_shape_zip_contents (map f t) u
     (same_shape_map_l t u Hshape f)
    rewrite map_fst_to_pair.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
t: T A1
u: T B
Hshape: shape t = shape u
f: A1 -> A2
map (map_pair f id)
  (same_shape_zip_contents t u Hshape) =
coerce natural_plength f t
in same_shape_zip_contents (map f t) u
     (same_shape_map_l t u Hshape f)
    rewrite natural_same_shape_zip_contents.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
t: T A1
u: T B
Hshape: shape t = shape u
f: A1 -> A2
coerce natural_plength f t
in same_shape_zip_contents (map f t) (map id u)
     (same_shape_map t u Hshape f id) =
coerce natural_plength f t
in same_shape_zip_contents (map f t) u
     (same_shape_map_l t u Hshape f)
    apply Vector_sim_eq.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
t: T A1
u: T B
Hshape: shape t = shape u
f: A1 -> A2
coerce natural_plength f t
in same_shape_zip_contents (map f t) (map id u)
     (same_shape_map t u Hshape f id) ~~
coerce natural_plength f t
in same_shape_zip_contents (map f t) u
     (same_shape_map_l t u Hshape f)
    vector_sim.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
t: T A1
u: T B
Hshape: shape t = shape u
f: A1 -> A2
same_shape_zip_contents (map f t) (map id u)
  (same_shape_map t u Hshape f id) ~~
same_shape_zip_contents (map f t) u
  (same_shape_map_l t u Hshape f)
    fequal.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
t: T A1
u: T B
Hshape: shape t = shape u
f: A1 -> A2
same_shape_zip_contents (map f t) (map id u)
  (same_shape_map t u Hshape f id) =
same_shape_zip_contents (map f t) u
  (same_shape_map_l t u Hshape f)
    apply same_shape_zip_contents_proof_irrelevance2.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
t: T A1
u: T B
Hshape: shape t = shape u
f: A1 -> A2
map id u = u
    rewrite fun_map_id.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
t: T A1
u: T B
Hshape: shape t = shape u
f: A1 -> A2
id u = u
    reflexivity.
  Qed.

  Corollary natural_fst_same_shape_zip_contents_rev
    {A1 A2 B: Type}:
    forall (t: T A1) (u: T B)
      (f: A1 -> A2)
      (Hshape: shape (map f t) = shape u),
      same_shape_zip_contents (map f t) u Hshape =
        coerce (eq_sym (natural_plength f t)) in
        map (map_fst f) (same_shape_zip_contents t u (same_shape_map_rev_l _ _ _ Hshape)).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
forall (t : T A1) (u : T B) (f : A1 -> A2)
  (Hshape : shape (map f t) = shape u),
same_shape_zip_contents (map f t) u Hshape =
coerce eq_sym (natural_plength f t)
in map (map_fst f)
     (same_shape_zip_contents t u
        (same_shape_map_rev_l t u f Hshape))

  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
forall (t : T A1) (u : T B) (f : A1 -> A2)
  (Hshape : shape (map f t) = shape u),
same_shape_zip_contents (map f t) u Hshape =
coerce eq_sym (natural_plength f t)
in map (map_fst f)
     (same_shape_zip_contents t u
        (same_shape_map_rev_l t u f Hshape))
    intros.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
t: T A1
u: T B
f: A1 -> A2
Hshape: shape (map f t) = shape u
same_shape_zip_contents (map f t) u Hshape =
coerce eq_sym (natural_plength f t)
in map (map_fst f)
     (same_shape_zip_contents t u
        (same_shape_map_rev_l t u f Hshape))
    rewrite map_fst_to_pair.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
t: T A1
u: T B
f: A1 -> A2
Hshape: shape (map f t) = shape u
same_shape_zip_contents (map f t) u Hshape =
coerce eq_sym (natural_plength f t)
in map (map_pair f id)
     (same_shape_zip_contents t u
        (same_shape_map_rev_l t u f Hshape))
    rewrite natural_same_shape_zip_contents.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
t: T A1
u: T B
f: A1 -> A2
Hshape: shape (map f t) = shape u
same_shape_zip_contents (map f t) u Hshape =
coerce eq_sym (natural_plength f t)
in coerce natural_plength f t
   in same_shape_zip_contents (map f t) (map id u)
        (same_shape_map t u
           (same_shape_map_rev_l t u f Hshape) f id)
    apply Vector_sim_eq.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
t: T A1
u: T B
f: A1 -> A2
Hshape: shape (map f t) = shape u
same_shape_zip_contents (map f t) u Hshape ~~
coerce eq_sym (natural_plength f t)
in coerce natural_plength f t
   in same_shape_zip_contents (map f t) (map id u)
        (same_shape_map t u
           (same_shape_map_rev_l t u f Hshape) f id)
    vector_sim.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
t: T A1
u: T B
f: A1 -> A2
Hshape: shape (map f t) = shape u
same_shape_zip_contents (map f t) u Hshape ~~
same_shape_zip_contents (map f t) (map id u)
  (same_shape_map t u
     (same_shape_map_rev_l t u f Hshape) f id)
    fequal.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
t: T A1
u: T B
f: A1 -> A2
Hshape: shape (map f t) = shape u
same_shape_zip_contents (map f t) u Hshape =
same_shape_zip_contents (map f t) (map id u)
  (same_shape_map t u
     (same_shape_map_rev_l t u f Hshape) f id)
    apply same_shape_zip_contents_proof_irrelevance2.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
t: T A1
u: T B
f: A1 -> A2
Hshape: shape (map f t) = shape u
u = map id u
    rewrite fun_map_id.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
t: T A1
u: T B
f: A1 -> A2
Hshape: shape (map f t) = shape u
u = id u
    reflexivity.
  Qed.


  Corollary natural_snd_same_shape_zip_contents
    {A B1 B2: Type}:
    forall (t: T A) (u: T B1) (Hshape: shape t = shape u)
      (g: B1 -> B2),
      map (map_snd g) (same_shape_zip_contents t u Hshape) =
      same_shape_zip_contents t (map g u) (same_shape_map_r t u Hshape g).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
forall (t : T A) (u : T B1)
  (Hshape : shape t = shape u) (g : B1 -> B2),
map (map_snd g) (same_shape_zip_contents t u Hshape) =
same_shape_zip_contents t (map g u)
  (same_shape_map_r t u Hshape g)
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
forall (t : T A) (u : T B1)
  (Hshape : shape t = shape u) (g : B1 -> B2),
map (map_snd g) (same_shape_zip_contents t u Hshape) =
same_shape_zip_contents t (map g u)
  (same_shape_map_r t u Hshape g)
    intros.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
t: T A
u: T B1
Hshape: shape t = shape u
g: B1 -> B2
map (map_snd g) (same_shape_zip_contents t u Hshape) =
same_shape_zip_contents t (map g u)
  (same_shape_map_r t u Hshape g)
    rewrite map_snd_to_pair.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
t: T A
u: T B1
Hshape: shape t = shape u
g: B1 -> B2
map (map_pair id g)
  (same_shape_zip_contents t u Hshape) =
same_shape_zip_contents t (map g u)
  (same_shape_map_r t u Hshape g)
    rewrite natural_same_shape_zip_contents.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
t: T A
u: T B1
Hshape: shape t = shape u
g: B1 -> B2
coerce natural_plength id t
in same_shape_zip_contents (map id t) (map g u)
     (same_shape_map t u Hshape id g) =
same_shape_zip_contents t (map g u)
  (same_shape_map_r t u Hshape g)
    apply Vector_sim_eq.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
t: T A
u: T B1
Hshape: shape t = shape u
g: B1 -> B2
coerce natural_plength id t
in same_shape_zip_contents (map id t) (map g u)
     (same_shape_map t u Hshape id g) ~~
same_shape_zip_contents t (map g u)
  (same_shape_map_r t u Hshape g)
    vector_sim.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
t: T A
u: T B1
Hshape: shape t = shape u
g: B1 -> B2
same_shape_zip_contents (map id t) (map g u)
  (same_shape_map t u Hshape id g) ~~
same_shape_zip_contents t (map g u)
  (same_shape_map_r t u Hshape g)
    apply same_shape_zip_contents_proof_irrelevance3.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
t: T A
u: T B1
Hshape: shape t = shape u
g: B1 -> B2
map id t = t
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
t: T A
u: T B1
Hshape: shape t = shape u
g: B1 -> B2
map g u = map g u
    rewrite fun_map_id.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
t: T A
u: T B1
Hshape: shape t = shape u
g: B1 -> B2
id t = t
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
t: T A
u: T B1
Hshape: shape t = shape u
g: B1 -> B2
map g u = map g u
    reflexivity.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
t: T A
u: T B1
Hshape: shape t = shape u
g: B1 -> B2
map g u = map g u
    reflexivity.
  Qed.

  Corollary natural_snd_same_shape_zip_contents_rev
    {A B1 B2: Type}:
    forall (t: T A) (u: T B1)
      (g: B1 -> B2)
      (Hshape: shape t = shape (map g u)),
      same_shape_zip_contents t (map g u) Hshape =
        map (map_snd g) (same_shape_zip_contents t u (same_shape_map_rev_r _ _ _ Hshape)).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
forall (t : T A) (u : T B1) (g : B1 -> B2)
  (Hshape : shape t = shape (map g u)),
same_shape_zip_contents t (map g u) Hshape =
map (map_snd g)
  (same_shape_zip_contents t u
     (same_shape_map_rev_r t u g Hshape))
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
forall (t : T A) (u : T B1) (g : B1 -> B2)
  (Hshape : shape t = shape (map g u)),
same_shape_zip_contents t (map g u) Hshape =
map (map_snd g)
  (same_shape_zip_contents t u
     (same_shape_map_rev_r t u g Hshape))
    intros.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
t: T A
u: T B1
g: B1 -> B2
Hshape: shape t = shape (map g u)
same_shape_zip_contents t (map g u) Hshape =
map (map_snd g)
  (same_shape_zip_contents t u
     (same_shape_map_rev_r t u g Hshape))
    rewrite map_snd_to_pair.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
t: T A
u: T B1
g: B1 -> B2
Hshape: shape t = shape (map g u)
same_shape_zip_contents t (map g u) Hshape =
map (map_pair id g)
  (same_shape_zip_contents t u
     (same_shape_map_rev_r t u g Hshape))
    rewrite natural_same_shape_zip_contents.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
t: T A
u: T B1
g: B1 -> B2
Hshape: shape t = shape (map g u)
same_shape_zip_contents t (map g u) Hshape =
coerce natural_plength id t
in same_shape_zip_contents (map id t) (map g u)
     (same_shape_map t u
        (same_shape_map_rev_r t u g Hshape) id g)
    apply Vector_sim_eq.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
t: T A
u: T B1
g: B1 -> B2
Hshape: shape t = shape (map g u)
same_shape_zip_contents t (map g u) Hshape ~~
coerce natural_plength id t
in same_shape_zip_contents (map id t) (map g u)
     (same_shape_map t u
        (same_shape_map_rev_r t u g Hshape) id g)
    vector_sim.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
t: T A
u: T B1
g: B1 -> B2
Hshape: shape t = shape (map g u)
same_shape_zip_contents t (map g u) Hshape ~~
same_shape_zip_contents (map id t) (map g u)
  (same_shape_map t u
     (same_shape_map_rev_r t u g Hshape) id g)
    apply same_shape_zip_contents_proof_irrelevance3.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
t: T A
u: T B1
g: B1 -> B2
Hshape: shape t = shape (map g u)
t = map id t
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
t: T A
u: T B1
g: B1 -> B2
Hshape: shape t = shape (map g u)
map g u = map g u
    rewrite fun_map_id.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
t: T A
u: T B1
g: B1 -> B2
Hshape: shape t = shape (map g u)
t = id t
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
t: T A
u: T B1
g: B1 -> B2
Hshape: shape t = shape (map g u)
map g u = map g u
    reflexivity.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
t: T A
u: T B1
g: B1 -> B2
Hshape: shape t = shape (map g u)
map g u = map g u
    reflexivity.
  Qed.

  (** ** Operation to Zip Same-<<shape>> Terms *)
  (********************************************************************)
  Definition same_shape_zip
    (A B: Type) (t: T A) (u: T B)
      (Hshape: shape t = shape u):
      T (A * B) :=
    trav_make t (same_shape_zip_contents t u Hshape).

  #[global] Arguments same_shape_zip {A B}%type_scope t u Hshape.

  Lemma same_shape_zip_fst
    (A B: Type) (t: T A) (u: T B)
    (Hshape: shape t = shape u):
    map fst (same_shape_zip t u Hshape) = t.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape: shape t = shape u
map fst (same_shape_zip t u Hshape) = t
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape: shape t = shape u
map fst (same_shape_zip t u Hshape) = t
    unfold same_shape_zip.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape: shape t = shape u
map fst
  (trav_make t (same_shape_zip_contents t u Hshape)) =
t
    rewrite <- (trav_make_natural A (A * B) A t (@fst A B)
                 (same_shape_zip_contents t u Hshape)).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape: shape t = shape u
trav_make t
  (map fst (same_shape_zip_contents t u Hshape)) = t
    rewrite same_shape_zip_contents_fst.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape: shape t = shape u
trav_make t (trav_contents t) = t
    rewrite trav_get_put.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape: shape t = shape u
t = t
    reflexivity.
  Qed.

  Lemma same_shape_zip_snd
    (A B: Type) (t: T A) (u: T B)
    (Hshape: shape t = shape u):
    map snd (same_shape_zip t u Hshape) = u.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape: shape t = shape u
map snd (same_shape_zip t u Hshape) = u
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape: shape t = shape u
map snd (same_shape_zip t u Hshape) = u
    unfold same_shape_zip.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape: shape t = shape u
map snd
  (trav_make t (same_shape_zip_contents t u Hshape)) =
u
    rewrite <- (trav_make_natural A (A * B) B t (@snd A B)
                 (same_shape_zip_contents t u Hshape)).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape: shape t = shape u
trav_make t
  (map snd (same_shape_zip_contents t u Hshape)) = u
    change u with (id u) at 2.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape: shape t = shape u
trav_make t
  (map snd (same_shape_zip_contents t u Hshape)) =
id u
    rewrite id_spec.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape: shape t = shape u
trav_make t
  (map snd (same_shape_zip_contents t u Hshape)) =
trav_make u (trav_contents u)
    apply Vector_fun_sim_eq.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape: shape t = shape u
trav_make t ~!~ trav_make u
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape: shape t = shape u
map snd (same_shape_zip_contents t u Hshape) ~~
trav_contents u
    -T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape: shape t = shape u
trav_make t ~!~ trav_make u apply trav_same_shape.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape: shape t = shape u
shape t = shape u
      assumption.
    -T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape: shape t = shape u
map snd (same_shape_zip_contents t u Hshape) ~~
trav_contents u apply same_shape_zip_contents_snd.
  Qed.

  (** ** Proof Irrelevance *)
  (********************************************************************)
  (* useful when <<u>> can't be rewritten due to Hshape proofs *)
  Lemma same_shape_zip_proof_irrelevance:
    forall (A B: Type)
      (t: T A) (t': T A) (u: T B) (u': T B)
      (Hshape1: shape t = shape u)
      (Hshape2: shape t' = shape u'),
      t = t' ->
      u = u' ->
      same_shape_zip t u Hshape1 =
        same_shape_zip t' u' Hshape2.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A B : Type) (t t' : T A) (u u' : T B)
  (Hshape1 : shape t = shape u)
  (Hshape2 : shape t' = shape u'),
t = t' ->
u = u' ->
same_shape_zip t u Hshape1 =
same_shape_zip t' u' Hshape2
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (A B : Type) (t t' : T A) (u u' : T B)
  (Hshape1 : shape t = shape u)
  (Hshape2 : shape t' = shape u'),
t = t' ->
u = u' ->
same_shape_zip t u Hshape1 =
same_shape_zip t' u' Hshape2
    introv Heqt Hequ.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t, t': T A
u, u': T B
Hshape1: shape t = shape u
Hshape2: shape t' = shape u'
Heqt: t = t'
Hequ: u = u'
same_shape_zip t u Hshape1 =
same_shape_zip t' u' Hshape2
    subst.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t': T A
u': T B
Hshape1, Hshape2: shape t' = shape u'
same_shape_zip t' u' Hshape1 =
same_shape_zip t' u' Hshape2
    fequal.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t': T A
u': T B
Hshape1, Hshape2: shape t' = shape u'
Hshape1 = Hshape2
    apply proof_irrelevance.
  Qed.

  (** ** Naturality Properties *)
  (********************************************************************)
  Lemma natural_same_shape_zip
    {A1 A2 B1 B2: Type}:
    forall (t: T A1) (u: T B1) (Hshape: shape t = shape u)
      (f: A1 -> A2) (g: B1 -> B2),
      map (map_pair f g) (same_shape_zip t u Hshape) =
        same_shape_zip (map f t) (map g u) (same_shape_map t u Hshape _ _).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
forall (t : T A1) (u : T B1)
  (Hshape : shape t = shape u) (f : A1 -> A2)
  (g : B1 -> B2),
map (map_pair f g) (same_shape_zip t u Hshape) =
same_shape_zip (map f t) (map g u)
  (same_shape_map t u Hshape f g)
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
forall (t : T A1) (u : T B1)
  (Hshape : shape t = shape u) (f : A1 -> A2)
  (g : B1 -> B2),
map (map_pair f g) (same_shape_zip t u Hshape) =
same_shape_zip (map f t) (map g u)
  (same_shape_map t u Hshape f g)
    intros.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
Hshape: shape t = shape u
f: A1 -> A2
g: B1 -> B2
map (map_pair f g) (same_shape_zip t u Hshape) =
same_shape_zip (map f t) (map g u)
  (same_shape_map t u Hshape f g)
    unfold same_shape_zip.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
Hshape: shape t = shape u
f: A1 -> A2
g: B1 -> B2
map (map_pair f g)
  (trav_make t (same_shape_zip_contents t u Hshape)) =
trav_make (map f t)
  (same_shape_zip_contents (map f t) (map g u)
     (same_shape_map t u Hshape f g))
    rewrite <- trav_make_natural.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
Hshape: shape t = shape u
f: A1 -> A2
g: B1 -> B2
trav_make t
  (map (map_pair f g)
     (same_shape_zip_contents t u Hshape)) =
trav_make (map f t)
  (same_shape_zip_contents (map f t) (map g u)
     (same_shape_map t u Hshape f g))
    rewrite natural_same_shape_zip_contents.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
Hshape: shape t = shape u
f: A1 -> A2
g: B1 -> B2
trav_make t
  (coerce natural_plength f t
   in same_shape_zip_contents (map f t) (map g u)
        (same_shape_map t u Hshape f g)) =
trav_make (map f t)
  (same_shape_zip_contents (map f t) (map g u)
     (same_shape_map t u Hshape f g))
    apply Vector_fun_sim_eq.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
Hshape: shape t = shape u
f: A1 -> A2
g: B1 -> B2
trav_make t ~!~ trav_make (map f t)
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
Hshape: shape t = shape u
f: A1 -> A2
g: B1 -> B2
coerce natural_plength f t
in same_shape_zip_contents 
     (map f t) (map g u)
     (same_shape_map t u Hshape f g) ~~
same_shape_zip_contents 
  (map f t) (map g u) 
  (same_shape_map t u Hshape f g)
    -T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
Hshape: shape t = shape u
f: A1 -> A2
g: B1 -> B2
trav_make t ~!~ trav_make (map f t) apply trav_same_shape.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
Hshape: shape t = shape u
f: A1 -> A2
g: B1 -> B2
shape t = shape (map f t)
      rewrite shape_map.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
Hshape: shape t = shape u
f: A1 -> A2
g: B1 -> B2
shape t = shape t
      reflexivity.
    -T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B1, B2: Type
t: T A1
u: T B1
Hshape: shape t = shape u
f: A1 -> A2
g: B1 -> B2
coerce natural_plength f t
in same_shape_zip_contents (map f t) (map g u)
     (same_shape_map t u Hshape f g) ~~
same_shape_zip_contents (map f t) (map g u)
  (same_shape_map t u Hshape f g) vector_sim.
  Qed.

  Corollary natural_fst_same_shape_zip
    {A1 A2 B: Type}:
    forall (t: T A1) (u: T B) (Hshape: shape t = shape u)
      (f: A1 -> A2),
      map (map_fst f) (same_shape_zip t u Hshape) =
        same_shape_zip (map f t) u (same_shape_map_l t u Hshape f).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
forall (t : T A1) (u : T B)
  (Hshape : shape t = shape u) (f : A1 -> A2),
map (map_fst f) (same_shape_zip t u Hshape) =
same_shape_zip (map f t) u
  (same_shape_map_l t u Hshape f)
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
forall (t : T A1) (u : T B)
  (Hshape : shape t = shape u) (f : A1 -> A2),
map (map_fst f) (same_shape_zip t u Hshape) =
same_shape_zip (map f t) u
  (same_shape_map_l t u Hshape f)
    intros.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
t: T A1
u: T B
Hshape: shape t = shape u
f: A1 -> A2
map (map_fst f) (same_shape_zip t u Hshape) =
same_shape_zip (map f t) u
  (same_shape_map_l t u Hshape f)
    rewrite map_fst_to_pair.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
t: T A1
u: T B
Hshape: shape t = shape u
f: A1 -> A2
map (map_pair f id) (same_shape_zip t u Hshape) =
same_shape_zip (map f t) u
  (same_shape_map_l t u Hshape f)
    rewrite natural_same_shape_zip.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
t: T A1
u: T B
Hshape: shape t = shape u
f: A1 -> A2
same_shape_zip (map f t) (map id u)
  (same_shape_map t u Hshape f id) =
same_shape_zip (map f t) u
  (same_shape_map_l t u Hshape f)
    apply same_shape_zip_proof_irrelevance.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
t: T A1
u: T B
Hshape: shape t = shape u
f: A1 -> A2
map f t = map f t
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
t: T A1
u: T B
Hshape: shape t = shape u
f: A1 -> A2
map id u = u
    -T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
t: T A1
u: T B
Hshape: shape t = shape u
f: A1 -> A2
map f t = map f t reflexivity.
    -T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A1, A2, B: Type
t: T A1
u: T B
Hshape: shape t = shape u
f: A1 -> A2
map id u = u now rewrite fun_map_id.
  Qed.

  Corollary natural_snd_same_shape_zip
    {A B1 B2: Type}:
    forall (t: T A) (u: T B1) (Hshape: shape t = shape u)
      (g: B1 -> B2),
      map (map_snd g) (same_shape_zip t u Hshape) =
      same_shape_zip t (map g u) (same_shape_map_r t u Hshape g).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
forall (t : T A) (u : T B1)
  (Hshape : shape t = shape u) (g : B1 -> B2),
map (map_snd g) (same_shape_zip t u Hshape) =
same_shape_zip t (map g u)
  (same_shape_map_r t u Hshape g)
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
forall (t : T A) (u : T B1)
  (Hshape : shape t = shape u) (g : B1 -> B2),
map (map_snd g) (same_shape_zip t u Hshape) =
same_shape_zip t (map g u)
  (same_shape_map_r t u Hshape g)
    intros.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
t: T A
u: T B1
Hshape: shape t = shape u
g: B1 -> B2
map (map_snd g) (same_shape_zip t u Hshape) =
same_shape_zip t (map g u)
  (same_shape_map_r t u Hshape g)
    rewrite map_snd_to_pair.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
t: T A
u: T B1
Hshape: shape t = shape u
g: B1 -> B2
map (map_pair id g) (same_shape_zip t u Hshape) =
same_shape_zip t (map g u)
  (same_shape_map_r t u Hshape g)
    rewrite natural_same_shape_zip.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
t: T A
u: T B1
Hshape: shape t = shape u
g: B1 -> B2
same_shape_zip (map id t) (map g u)
  (same_shape_map t u Hshape id g) =
same_shape_zip t (map g u)
  (same_shape_map_r t u Hshape g)
    apply same_shape_zip_proof_irrelevance.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
t: T A
u: T B1
Hshape: shape t = shape u
g: B1 -> B2
map id t = t
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
t: T A
u: T B1
Hshape: shape t = shape u
g: B1 -> B2
map g u = map g u
    -T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
t: T A
u: T B1
Hshape: shape t = shape u
g: B1 -> B2
map id t = t rewrite fun_map_id.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
t: T A
u: T B1
Hshape: shape t = shape u
g: B1 -> B2
id t = t
      reflexivity.
    -T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B1, B2: Type
t: T A
u: T B1
Hshape: shape t = shape u
g: B1 -> B2
map g u = map g u reflexivity.
  Qed.

  Lemma same_shape_zip_same_shape {A B}:
    forall (t: T A) (u: T B)
    (Hshape: shape t = shape u),
      shape (same_shape_zip t u Hshape) = shape t.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
forall (t : T A) (u : T B)
  (Hshape : shape t = shape u),
shape (same_shape_zip t u Hshape) = shape t
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
forall (t : T A) (u : T B)
  (Hshape : shape t = shape u),
shape (same_shape_zip t u Hshape) = shape t
    intros.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape: shape t = shape u
shape (same_shape_zip t u Hshape) = shape t
    apply (same_shape_map_rev _ _ fst id).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape: shape t = shape u
shape (map fst (same_shape_zip t u Hshape)) =
shape (map id t)
    rewrite fun_map_id.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape: shape t = shape u
shape (map fst (same_shape_zip t u Hshape)) =
shape (id t)
    rewrite same_shape_zip_fst.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B: Type
t: T A
u: T B
Hshape: shape t = shape u
shape t = shape (id t)
    reflexivity.
  Qed.

  (** ** Traversals over the zip *)
  (**********************************************************************)
  Lemma map_sim_fns:
    forall (n m: nat) (A B C: Type) `{Applicative G}
      (mk1: Vector n B -> C) (v1: Vector n A)
      (mk2: Vector m B -> C) (v2: Vector m A)
      (f: A -> G B),
      mk1 ~!~ mk2 ->
      v1 ~~ v2 ->
      map (F := G) mk1 (traverse (G := G) (T := Vector n) f v1) = map (F := G) mk2 (traverse (T := Vector m) f v2).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (n m : nat) (A B C : Type) (G : Type -> Type)
  (Map_G : Map G) (Pure_G : Pure G) (Mult_G : Mult G),
Applicative G ->
forall (mk1 : Vector n B -> C) (v1 : Vector n A)
  (mk2 : Vector m B -> C) (v2 : Vector m A)
  (f : A -> G B),
mk1 ~!~ mk2 ->
v1 ~~ v2 ->
map mk1 (traverse f v1) = map mk2 (traverse f v2)
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (n m : nat) (A B C : Type) (G : Type -> Type)
  (Map_G : Map G) (Pure_G : Pure G) (Mult_G : Mult G),
Applicative G ->
forall (mk1 : Vector n B -> C) (v1 : Vector n A)
  (mk2 : Vector m B -> C) (v2 : Vector m A)
  (f : A -> G B),
mk1 ~!~ mk2 ->
v1 ~~ v2 ->
map mk1 (traverse f v1) = map mk2 (traverse f v2)
    intros.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n, m: nat
A, B, C: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
mk1: Vector n B -> C
v1: Vector n A
mk2: Vector m B -> C
v2: Vector m A
f: A -> G B
H1: mk1 ~!~ mk2
H2: v1 ~~ v2
map mk1 (traverse f v1) = map mk2 (traverse f v2)
    assert (Heq: n = m) by (now apply Vector_sim_length in H2).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n, m: nat
A, B, C: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
mk1: Vector n B -> C
v1: Vector n A
mk2: Vector m B -> C
v2: Vector m A
f: A -> G B
H1: mk1 ~!~ mk2
H2: v1 ~~ v2
Heq: n = m
map mk1 (traverse f v1) = map mk2 (traverse f v2)
    generalize dependent v2.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n, m: nat
A, B, C: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
mk1: Vector n B -> C
v1: Vector n A
mk2: Vector m B -> C
f: A -> G B
H1: mk1 ~!~ mk2
Heq: n = m
forall v2 : Vector m A,
v1 ~~ v2 ->
map mk1 (traverse f v1) = map mk2 (traverse f v2)
    generalize dependent m.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B, C: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
mk1: Vector n B -> C
v1: Vector n A
f: A -> G B
forall (m : nat) (mk2 : Vector m B -> C),
mk1 ~!~ mk2 ->
n = m ->
forall v2 : Vector m A,
v1 ~~ v2 ->
map mk1 (traverse f v1) = map mk2 (traverse f v2)
    induction n; intros; subst.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, C: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
mk1: Vector 0 B -> C
v1: Vector 0 A
f: A -> G B
mk2: Vector 0 B -> C
H1: mk1 ~!~ mk2
v2: Vector 0 A
H2: v1 ~~ v2
map mk1 (traverse f v1) = map mk2 (traverse f v2)
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B, C: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
mk1: Vector (S n) B -> C
v1: Vector (S n) A
f: A -> G B
IHn: forall (mk1 : Vector n B -> C) 
  (v1 : Vector n A) (m : nat)
  (mk2 : Vector m B -> C),
mk1 ~!~ mk2 ->
n = m ->
forall v2 : Vector m A,
v1 ~~ v2 ->
map mk1 (traverse f v1) =
map mk2 (traverse f v2)
mk2: Vector (S n) B -> C
H1: mk1 ~!~ mk2
v2: Vector (S n) A
H2: v1 ~~ v2
map mk1 (traverse f v1) = map mk2 (traverse f v2)
    -T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, C: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
mk1: Vector 0 B -> C
v1: Vector 0 A
f: A -> G B
mk2: Vector 0 B -> C
H1: mk1 ~!~ mk2
v2: Vector 0 A
H2: v1 ~~ v2
map mk1 (traverse f v1) = map mk2 (traverse f v2) rewrite (Vector_nil_eq v1).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, C: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
mk1: Vector 0 B -> C
v1: Vector 0 A
f: A -> G B
mk2: Vector 0 B -> C
H1: mk1 ~!~ mk2
v2: Vector 0 A
H2: v1 ~~ v2
map mk1 (traverse f vnil) = map mk2 (traverse f v2)
      rewrite (Vector_nil_eq v2).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, C: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
mk1: Vector 0 B -> C
v1: Vector 0 A
f: A -> G B
mk2: Vector 0 B -> C
H1: mk1 ~!~ mk2
v2: Vector 0 A
H2: v1 ~~ v2
map mk1 (traverse f vnil) = map mk2 (traverse f vnil)
      rewrite traverse_Vector_vnil.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, C: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
mk1: Vector 0 B -> C
v1: Vector 0 A
f: A -> G B
mk2: Vector 0 B -> C
H1: mk1 ~!~ mk2
v2: Vector 0 A
H2: v1 ~~ v2
map mk1 (pure vnil) = map mk2 (pure vnil)
      fequal.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, C: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
mk1: Vector 0 B -> C
v1: Vector 0 A
f: A -> G B
mk2: Vector 0 B -> C
H1: mk1 ~!~ mk2
v2: Vector 0 A
H2: v1 ~~ v2
mk1 = mk2 ext v.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, C: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
mk1: Vector 0 B -> C
v1: Vector 0 A
f: A -> G B
mk2: Vector 0 B -> C
H1: mk1 ~!~ mk2
v2: Vector 0 A
H2: v1 ~~ v2
v: Vector 0 B
mk1 v = mk2 v
      apply Vector_fun_sim_eq.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, C: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
mk1: Vector 0 B -> C
v1: Vector 0 A
f: A -> G B
mk2: Vector 0 B -> C
H1: mk1 ~!~ mk2
v2: Vector 0 A
H2: v1 ~~ v2
v: Vector 0 B
mk1 ~!~ mk2
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, C: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
mk1: Vector 0 B -> C
v1: Vector 0 A
f: A -> G B
mk2: Vector 0 B -> C
H1: mk1 ~!~ mk2
v2: Vector 0 A
H2: v1 ~~ v2
v: Vector 0 B
v ~~ v
      assumption.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
A, B, C: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
mk1: Vector 0 B -> C
v1: Vector 0 A
f: A -> G B
mk2: Vector 0 B -> C
H1: mk1 ~!~ mk2
v2: Vector 0 A
H2: v1 ~~ v2
v: Vector 0 B
v ~~ v reflexivity.
    -T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B, C: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
mk1: Vector (S n) B -> C
v1: Vector (S n) A
f: A -> G B
IHn: forall (mk1 : Vector n B -> C) 
  (v1 : Vector n A) (m : nat)
  (mk2 : Vector m B -> C),
mk1 ~!~ mk2 ->
n = m ->
forall v2 : Vector m A,
v1 ~~ v2 ->
map mk1 (traverse f v1) =
map mk2 (traverse f v2)
mk2: Vector (S n) B -> C
H1: mk1 ~!~ mk2
v2: Vector (S n) A
H2: v1 ~~ v2
map mk1 (traverse f v1) = map mk2 (traverse f v2) rewrite (Vector_surjective_pairing2 (v := v2)) in *.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B, C: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
mk1: Vector (S n) B -> C
v1: Vector (S n) A
f: A -> G B
IHn: forall (mk1 : Vector n B -> C) 
  (v1 : Vector n A) (m : nat)
  (mk2 : Vector m B -> C),
mk1 ~!~ mk2 ->
n = m ->
forall v2 : Vector m A,
v1 ~~ v2 ->
map mk1 (traverse f v1) =
map mk2 (traverse f v2)
mk2: Vector (S n) B -> C
H1: mk1 ~!~ mk2
v2: Vector (S n) A
H2: v1 ~~ vcons n (Vector_hd v2) (Vector_tl v2)
map mk1 (traverse f v1) =
map mk2
  (traverse f (vcons n (Vector_hd v2) (Vector_tl v2)))
      rewrite (Vector_surjective_pairing2 (v := v1)) in *.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B, C: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
mk1: Vector (S n) B -> C
v1: Vector (S n) A
f: A -> G B
IHn: forall (mk1 : Vector n B -> C) 
  (v1 : Vector n A) (m : nat)
  (mk2 : Vector m B -> C),
mk1 ~!~ mk2 ->
n = m ->
forall v2 : Vector m A,
v1 ~~ v2 ->
map mk1 (traverse f v1) =
map mk2 (traverse f v2)
mk2: Vector (S n) B -> C
H1: mk1 ~!~ mk2
v2: Vector (S n) A
H2: vcons n (Vector_hd v1) (Vector_tl v1) ~~
vcons n (Vector_hd v2) (Vector_tl v2)
map mk1
  (traverse f (vcons n (Vector_hd v1) (Vector_tl v1))) =
map mk2
  (traverse f (vcons n (Vector_hd v2) (Vector_tl v2)))
      rewrite traverse_Vector_vcons.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B, C: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
mk1: Vector (S n) B -> C
v1: Vector (S n) A
f: A -> G B
IHn: forall (mk1 : Vector n B -> C) 
  (v1 : Vector n A) (m : nat)
  (mk2 : Vector m B -> C),
mk1 ~!~ mk2 ->
n = m ->
forall v2 : Vector m A,
v1 ~~ v2 ->
map mk1 (traverse f v1) =
map mk2 (traverse f v2)
mk2: Vector (S n) B -> C
H1: mk1 ~!~ mk2
v2: Vector (S n) A
H2: vcons n (Vector_hd v1) (Vector_tl v1) ~~
vcons n (Vector_hd v2) (Vector_tl v2)
map mk1
  (pure (vcons n) <⋆> f (Vector_hd v1) <⋆>
   traverse f (Vector_tl v1)) =
map mk2
  (traverse f (vcons n (Vector_hd v2) (Vector_tl v2)))
      rewrite traverse_Vector_vcons.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B, C: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
mk1: Vector (S n) B -> C
v1: Vector (S n) A
f: A -> G B
IHn: forall (mk1 : Vector n B -> C) 
  (v1 : Vector n A) (m : nat)
  (mk2 : Vector m B -> C),
mk1 ~!~ mk2 ->
n = m ->
forall v2 : Vector m A,
v1 ~~ v2 ->
map mk1 (traverse f v1) =
map mk2 (traverse f v2)
mk2: Vector (S n) B -> C
H1: mk1 ~!~ mk2
v2: Vector (S n) A
H2: vcons n (Vector_hd v1) (Vector_tl v1) ~~
vcons n (Vector_hd v2) (Vector_tl v2)
map mk1
  (pure (vcons n) <⋆> f (Vector_hd v1) <⋆>
   traverse f (Vector_tl v1)) =
map mk2
  (pure (vcons n) <⋆> f (Vector_hd v2) <⋆>
   traverse f (Vector_tl v2))
      inversion H2.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B, C: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
mk1: Vector (S n) B -> C
v1: Vector (S n) A
f: A -> G B
IHn: forall (mk1 : Vector n B -> C) 
  (v1 : Vector n A) (m : nat)
  (mk2 : Vector m B -> C),
mk1 ~!~ mk2 ->
n = m ->
forall v2 : Vector m A,
v1 ~~ v2 ->
map mk1 (traverse f v1) =
map mk2 (traverse f v2)
mk2: Vector (S n) B -> C
H1: mk1 ~!~ mk2
v2: Vector (S n) A
H2: vcons n (Vector_hd v1) (Vector_tl v1) ~~
vcons n (Vector_hd v2) (Vector_tl v2)
H4: proj1_sig (vcons n (Vector_hd v1) (Vector_tl v1)) =
proj1_sig (vcons n (Vector_hd v2) (Vector_tl v2))
map mk1
  (pure (vcons n) <⋆> f (Vector_hd v1) <⋆>
   traverse f (Vector_tl v1)) =
map mk2
  (pure (vcons n) <⋆> f (Vector_hd v2) <⋆>
   traverse f (Vector_tl v2))
      do 2 rewrite proj_vcons in H4.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B, C: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
mk1: Vector (S n) B -> C
v1: Vector (S n) A
f: A -> G B
IHn: forall (mk1 : Vector n B -> C) 
  (v1 : Vector n A) (m : nat)
  (mk2 : Vector m B -> C),
mk1 ~!~ mk2 ->
n = m ->
forall v2 : Vector m A,
v1 ~~ v2 ->
map mk1 (traverse f v1) =
map mk2 (traverse f v2)
mk2: Vector (S n) B -> C
H1: mk1 ~!~ mk2
v2: Vector (S n) A
H2: vcons n (Vector_hd v1) (Vector_tl v1) ~~
vcons n (Vector_hd v2) (Vector_tl v2)
H4: Vector_hd v1 :: proj1_sig (Vector_tl v1) =
Vector_hd v2 :: proj1_sig (Vector_tl v2)
map mk1
  (pure (vcons n) <⋆> f (Vector_hd v1) <⋆>
   traverse f (Vector_tl v1)) =
map mk2
  (pure (vcons n) <⋆> f (Vector_hd v2) <⋆>
   traverse f (Vector_tl v2))
      inversion H4.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B, C: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
mk1: Vector (S n) B -> C
v1: Vector (S n) A
f: A -> G B
IHn: forall (mk1 : Vector n B -> C) 
  (v1 : Vector n A) (m : nat)
  (mk2 : Vector m B -> C),
mk1 ~!~ mk2 ->
n = m ->
forall v2 : Vector m A,
v1 ~~ v2 ->
map mk1 (traverse f v1) =
map mk2 (traverse f v2)
mk2: Vector (S n) B -> C
H1: mk1 ~!~ mk2
v2: Vector (S n) A
H2: vcons n (Vector_hd v1) (Vector_tl v1) ~~
vcons n (Vector_hd v2) (Vector_tl v2)
H4: Vector_hd v1 :: proj1_sig (Vector_tl v1) =
Vector_hd v2 :: proj1_sig (Vector_tl v2)
H5: Vector_hd v1 = Vector_hd v2
H6: proj1_sig (Vector_tl v1) =
proj1_sig (Vector_tl v2)
map mk1
  (pure (vcons n) <⋆> f (Vector_hd v1) <⋆>
   traverse f (Vector_tl v1)) =
map mk2
  (pure (vcons n) <⋆> f (Vector_hd v1) <⋆>
   traverse f (Vector_tl v2))
      fequal.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B, C: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
mk1: Vector (S n) B -> C
v1: Vector (S n) A
f: A -> G B
IHn: forall (mk1 : Vector n B -> C) 
  (v1 : Vector n A) (m : nat)
  (mk2 : Vector m B -> C),
mk1 ~!~ mk2 ->
n = m ->
forall v2 : Vector m A,
v1 ~~ v2 ->
map mk1 (traverse f v1) =
map mk2 (traverse f v2)
mk2: Vector (S n) B -> C
H1: mk1 ~!~ mk2
v2: Vector (S n) A
H2: vcons n (Vector_hd v1) (Vector_tl v1) ~~
vcons n (Vector_hd v2) (Vector_tl v2)
H4: Vector_hd v1 :: proj1_sig (Vector_tl v1) =
Vector_hd v2 :: proj1_sig (Vector_tl v2)
H5: Vector_hd v1 = Vector_hd v2
H6: proj1_sig (Vector_tl v1) =
proj1_sig (Vector_tl v2)
mk1 = mk2
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B, C: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
mk1: Vector (S n) B -> C
v1: Vector (S n) A
f: A -> G B
IHn: forall (mk1 : Vector n B -> C) 
  (v1 : Vector n A) (m : nat)
  (mk2 : Vector m B -> C),
mk1 ~!~ mk2 ->
n = m ->
forall v2 : Vector m A,
v1 ~~ v2 ->
map mk1 (traverse f v1) =
map mk2 (traverse f v2)
mk2: Vector (S n) B -> C
H1: mk1 ~!~ mk2
v2: Vector (S n) A
H2: vcons n (Vector_hd v1) (Vector_tl v1) ~~
vcons n (Vector_hd v2) (Vector_tl v2)
H4: Vector_hd v1 :: proj1_sig (Vector_tl v1) =
Vector_hd v2 :: proj1_sig (Vector_tl v2)
H5: Vector_hd v1 = Vector_hd v2
H6: proj1_sig (Vector_tl v1) =
proj1_sig (Vector_tl v2)
pure (vcons n) <⋆> f (Vector_hd v1) <⋆>
traverse f (Vector_tl v1) =
pure (vcons n) <⋆> f (Vector_hd v1) <⋆>
traverse f (Vector_tl v2)
      {T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B, C: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
mk1: Vector (S n) B -> C
v1: Vector (S n) A
f: A -> G B
IHn: forall (mk1 : Vector n B -> C) 
  (v1 : Vector n A) (m : nat)
  (mk2 : Vector m B -> C),
mk1 ~!~ mk2 ->
n = m ->
forall v2 : Vector m A,
v1 ~~ v2 ->
map mk1 (traverse f v1) =
map mk2 (traverse f v2)
mk2: Vector (S n) B -> C
H1: mk1 ~!~ mk2
v2: Vector (S n) A
H2: vcons n (Vector_hd v1) (Vector_tl v1) ~~
vcons n (Vector_hd v2) (Vector_tl v2)
H4: Vector_hd v1 :: proj1_sig (Vector_tl v1) =
Vector_hd v2 :: proj1_sig (Vector_tl v2)
H5: Vector_hd v1 = Vector_hd v2
H6: proj1_sig (Vector_tl v1) =
proj1_sig (Vector_tl v2)
mk1 = mk2 ext v.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B, C: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
mk1: Vector (S n) B -> C
v1: Vector (S n) A
f: A -> G B
IHn: forall (mk1 : Vector n B -> C) 
  (v1 : Vector n A) (m : nat)
  (mk2 : Vector m B -> C),
mk1 ~!~ mk2 ->
n = m ->
forall v2 : Vector m A,
v1 ~~ v2 ->
map mk1 (traverse f v1) =
map mk2 (traverse f v2)
mk2: Vector (S n) B -> C
H1: mk1 ~!~ mk2
v2: Vector (S n) A
H2: vcons n (Vector_hd v1) (Vector_tl v1) ~~
vcons n (Vector_hd v2) (Vector_tl v2)
H4: Vector_hd v1 :: proj1_sig (Vector_tl v1) =
Vector_hd v2 :: proj1_sig (Vector_tl v2)
H5: Vector_hd v1 = Vector_hd v2
H6: proj1_sig (Vector_tl v1) =
proj1_sig (Vector_tl v2)
v: Vector (S n) B
mk1 v = mk2 v apply Vector_fun_sim_eq.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B, C: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
mk1: Vector (S n) B -> C
v1: Vector (S n) A
f: A -> G B
IHn: forall (mk1 : Vector n B -> C) 
  (v1 : Vector n A) (m : nat)
  (mk2 : Vector m B -> C),
mk1 ~!~ mk2 ->
n = m ->
forall v2 : Vector m A,
v1 ~~ v2 ->
map mk1 (traverse f v1) =
map mk2 (traverse f v2)
mk2: Vector (S n) B -> C
H1: mk1 ~!~ mk2
v2: Vector (S n) A
H2: vcons n (Vector_hd v1) (Vector_tl v1) ~~
vcons n (Vector_hd v2) (Vector_tl v2)
H4: Vector_hd v1 :: proj1_sig (Vector_tl v1) =
Vector_hd v2 :: proj1_sig (Vector_tl v2)
H5: Vector_hd v1 = Vector_hd v2
H6: proj1_sig (Vector_tl v1) =
proj1_sig (Vector_tl v2)
v: Vector (S n) B
mk1 ~!~ mk2
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B, C: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
mk1: Vector (S n) B -> C
v1: Vector (S n) A
f: A -> G B
IHn: forall (mk1 : Vector n B -> C) 
  (v1 : Vector n A) (m : nat)
  (mk2 : Vector m B -> C),
mk1 ~!~ mk2 ->
n = m ->
forall v2 : Vector m A,
v1 ~~ v2 ->
map mk1 (traverse f v1) =
map mk2 (traverse f v2)
mk2: Vector (S n) B -> C
H1: mk1 ~!~ mk2
v2: Vector (S n) A
H2: vcons n (Vector_hd v1) (Vector_tl v1) ~~
vcons n (Vector_hd v2) (Vector_tl v2)
H4: Vector_hd v1 :: proj1_sig (Vector_tl v1) =
Vector_hd v2 :: proj1_sig (Vector_tl v2)
H5: Vector_hd v1 = Vector_hd v2
H6: proj1_sig (Vector_tl v1) =
proj1_sig (Vector_tl v2)
v: Vector (S n) B
v ~~ v
        assumption.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B, C: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
mk1: Vector (S n) B -> C
v1: Vector (S n) A
f: A -> G B
IHn: forall (mk1 : Vector n B -> C) 
  (v1 : Vector n A) (m : nat)
  (mk2 : Vector m B -> C),
mk1 ~!~ mk2 ->
n = m ->
forall v2 : Vector m A,
v1 ~~ v2 ->
map mk1 (traverse f v1) =
map mk2 (traverse f v2)
mk2: Vector (S n) B -> C
H1: mk1 ~!~ mk2
v2: Vector (S n) A
H2: vcons n (Vector_hd v1) (Vector_tl v1) ~~
vcons n (Vector_hd v2) (Vector_tl v2)
H4: Vector_hd v1 :: proj1_sig (Vector_tl v1) =
Vector_hd v2 :: proj1_sig (Vector_tl v2)
H5: Vector_hd v1 = Vector_hd v2
H6: proj1_sig (Vector_tl v1) =
proj1_sig (Vector_tl v2)
v: Vector (S n) B
v ~~ v reflexivity. }T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B, C: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
mk1: Vector (S n) B -> C
v1: Vector (S n) A
f: A -> G B
IHn: forall (mk1 : Vector n B -> C) 
  (v1 : Vector n A) (m : nat)
  (mk2 : Vector m B -> C),
mk1 ~!~ mk2 ->
n = m ->
forall v2 : Vector m A,
v1 ~~ v2 ->
map mk1 (traverse f v1) =
map mk2 (traverse f v2)
mk2: Vector (S n) B -> C
H1: mk1 ~!~ mk2
v2: Vector (S n) A
H2: vcons n (Vector_hd v1) (Vector_tl v1) ~~
vcons n (Vector_hd v2) (Vector_tl v2)
H4: Vector_hd v1 :: proj1_sig (Vector_tl v1) =
Vector_hd v2 :: proj1_sig (Vector_tl v2)
H5: Vector_hd v1 = Vector_hd v2
H6: proj1_sig (Vector_tl v1) =
proj1_sig (Vector_tl v2)
pure (vcons n) <⋆> f (Vector_hd v1) <⋆>
traverse f (Vector_tl v1) =
pure (vcons n) <⋆> f (Vector_hd v1) <⋆>
traverse f (Vector_tl v2)
      fequal.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B, C: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
mk1: Vector (S n) B -> C
v1: Vector (S n) A
f: A -> G B
IHn: forall (mk1 : Vector n B -> C) 
  (v1 : Vector n A) (m : nat)
  (mk2 : Vector m B -> C),
mk1 ~!~ mk2 ->
n = m ->
forall v2 : Vector m A,
v1 ~~ v2 ->
map mk1 (traverse f v1) =
map mk2 (traverse f v2)
mk2: Vector (S n) B -> C
H1: mk1 ~!~ mk2
v2: Vector (S n) A
H2: vcons n (Vector_hd v1) (Vector_tl v1) ~~
vcons n (Vector_hd v2) (Vector_tl v2)
H4: Vector_hd v1 :: proj1_sig (Vector_tl v1) =
Vector_hd v2 :: proj1_sig (Vector_tl v2)
H5: Vector_hd v1 = Vector_hd v2
H6: proj1_sig (Vector_tl v1) =
proj1_sig (Vector_tl v2)
traverse f (Vector_tl v1) = traverse f (Vector_tl v2)
      fequal.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B, C: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
mk1: Vector (S n) B -> C
v1: Vector (S n) A
f: A -> G B
IHn: forall (mk1 : Vector n B -> C) 
  (v1 : Vector n A) (m : nat)
  (mk2 : Vector m B -> C),
mk1 ~!~ mk2 ->
n = m ->
forall v2 : Vector m A,
v1 ~~ v2 ->
map mk1 (traverse f v1) =
map mk2 (traverse f v2)
mk2: Vector (S n) B -> C
H1: mk1 ~!~ mk2
v2: Vector (S n) A
H2: vcons n (Vector_hd v1) (Vector_tl v1) ~~
vcons n (Vector_hd v2) (Vector_tl v2)
H4: Vector_hd v1 :: proj1_sig (Vector_tl v1) =
Vector_hd v2 :: proj1_sig (Vector_tl v2)
H5: Vector_hd v1 = Vector_hd v2
H6: proj1_sig (Vector_tl v1) =
proj1_sig (Vector_tl v2)
Vector_tl v1 = Vector_tl v2
      apply Vector_sim_eq.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
n: nat
A, B, C: Type
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
mk1: Vector (S n) B -> C
v1: Vector (S n) A
f: A -> G B
IHn: forall (mk1 : Vector n B -> C) 
  (v1 : Vector n A) (m : nat)
  (mk2 : Vector m B -> C),
mk1 ~!~ mk2 ->
n = m ->
forall v2 : Vector m A,
v1 ~~ v2 ->
map mk1 (traverse f v1) =
map mk2 (traverse f v2)
mk2: Vector (S n) B -> C
H1: mk1 ~!~ mk2
v2: Vector (S n) A
H2: vcons n (Vector_hd v1) (Vector_tl v1) ~~
vcons n (Vector_hd v2) (Vector_tl v2)
H4: Vector_hd v1 :: proj1_sig (Vector_tl v1) =
Vector_hd v2 :: proj1_sig (Vector_tl v2)
H5: Vector_hd v1 = Vector_hd v2
H6: proj1_sig (Vector_tl v1) =
proj1_sig (Vector_tl v2)
Vector_tl v1 ~~ Vector_tl v2
      apply H6.
  Qed.

  Definition traverse_same_shape_zip
    `{Applicative G}
    (A B C: Type) (t: T A) (u: T B)
    (f: A * B -> G C)
    (Hshape: shape t = shape u)
    :
    traverse (T := T) f (same_shape_zip t u Hshape) =
      map (F := G) (trav_make t)
        (forwards (traverse (T := Vector (plength t)) (mkBackwards ∘ f) (same_shape_zip_contents t u Hshape))).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B, C: Type
t: T A
u: T B
f: A * B -> G C
Hshape: shape t = shape u
traverse f (same_shape_zip t u Hshape) =
map (trav_make t)
  (forwards
     (traverse (mkBackwards ∘ f)
        (same_shape_zip_contents t u Hshape)))
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B, C: Type
t: T A
u: T B
f: A * B -> G C
Hshape: shape t = shape u
traverse f (same_shape_zip t u Hshape) =
map (trav_make t)
  (forwards
     (traverse (mkBackwards ∘ f)
        (same_shape_zip_contents t u Hshape)))
    assert (trav_make (B := C) (same_shape_zip t u Hshape) ~!~ trav_make t).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B, C: Type
t: T A
u: T B
f: A * B -> G C
Hshape: shape t = shape u
trav_make (same_shape_zip t u Hshape) ~!~ trav_make t
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B, C: Type
t: T A
u: T B
f: A * B -> G C
Hshape: shape t = shape u
H1: trav_make (same_shape_zip t u Hshape) ~!~
trav_make t
traverse f (same_shape_zip t u Hshape) =
map (trav_make t)
  (forwards
     (traverse (mkBackwards ∘ f)
        (same_shape_zip_contents t u Hshape)))
    {T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B, C: Type
t: T A
u: T B
f: A * B -> G C
Hshape: shape t = shape u
trav_make (same_shape_zip t u Hshape) ~!~ trav_make t apply trav_same_shape.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B, C: Type
t: T A
u: T B
f: A * B -> G C
Hshape: shape t = shape u
shape (same_shape_zip t u Hshape) = shape t
      apply same_shape_zip_same_shape.
    }T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B, C: Type
t: T A
u: T B
f: A * B -> G C
Hshape: shape t = shape u
H1: trav_make (same_shape_zip t u Hshape) ~!~
trav_make t
traverse f (same_shape_zip t u Hshape) =
map (trav_make t)
  (forwards
     (traverse (mkBackwards ∘ f)
        (same_shape_zip_contents t u Hshape)))
    rewrite traverse_repr.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B, C: Type
t: T A
u: T B
f: A * B -> G C
Hshape: shape t = shape u
H1: trav_make (same_shape_zip t u Hshape) ~!~
trav_make t
map (trav_make (same_shape_zip t u Hshape))
  (forwards
     (traverse (mkBackwards ∘ f)
        (trav_contents (same_shape_zip t u Hshape)))) =
map (trav_make t)
  (forwards
     (traverse (mkBackwards ∘ f)
        (same_shape_zip_contents t u Hshape)))
    assert (trav_contents (same_shape_zip t u Hshape) ~~
              (same_shape_zip_contents t u Hshape)).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B, C: Type
t: T A
u: T B
f: A * B -> G C
Hshape: shape t = shape u
H1: trav_make (same_shape_zip t u Hshape) ~!~
trav_make t
trav_contents (same_shape_zip t u Hshape) ~~
same_shape_zip_contents t u Hshape
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B, C: Type
t: T A
u: T B
f: A * B -> G C
Hshape: shape t = shape u
H1: trav_make (same_shape_zip t u Hshape) ~!~
trav_make t
H2: trav_contents (same_shape_zip t u Hshape) ~~
same_shape_zip_contents t u Hshape
map (trav_make (same_shape_zip t u Hshape))
  (forwards
     (traverse (mkBackwards ∘ f)
        (trav_contents (same_shape_zip t u Hshape)))) =
map (trav_make t)
  (forwards
     (traverse (mkBackwards ∘ f)
        (same_shape_zip_contents t u Hshape)))
    {T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B, C: Type
t: T A
u: T B
f: A * B -> G C
Hshape: shape t = shape u
H1: trav_make (same_shape_zip t u Hshape) ~!~
trav_make t
trav_contents (same_shape_zip t u Hshape) ~~
same_shape_zip_contents t u Hshape  unfold same_shape_zip.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B, C: Type
t: T A
u: T B
f: A * B -> G C
Hshape: shape t = shape u
H1: trav_make (same_shape_zip t u Hshape) ~!~
trav_make t
trav_contents
  (trav_make t (same_shape_zip_contents t u Hshape)) ~~
same_shape_zip_contents t u Hshape
       unfold Vector_sim.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B, C: Type
t: T A
u: T B
f: A * B -> G C
Hshape: shape t = shape u
H1: trav_make (same_shape_zip t u Hshape) ~!~
trav_make t
proj1_sig
  (trav_contents
     (trav_make t (same_shape_zip_contents t u Hshape))) =
proj1_sig (same_shape_zip_contents t u Hshape)
       rewrite trav_contents_make.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B, C: Type
t: T A
u: T B
f: A * B -> G C
Hshape: shape t = shape u
H1: trav_make (same_shape_zip t u Hshape) ~!~
trav_make t
proj1_sig (same_shape_zip_contents t u Hshape) =
proj1_sig (same_shape_zip_contents t u Hshape)
       reflexivity. }T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B, C: Type
t: T A
u: T B
f: A * B -> G C
Hshape: shape t = shape u
H1: trav_make (same_shape_zip t u Hshape) ~!~
trav_make t
H2: trav_contents (same_shape_zip t u Hshape) ~~
same_shape_zip_contents t u Hshape
map (trav_make (same_shape_zip t u Hshape))
  (forwards
     (traverse (mkBackwards ∘ f)
        (trav_contents (same_shape_zip t u Hshape)))) =
map (trav_make t)
  (forwards
     (traverse (mkBackwards ∘ f)
        (same_shape_zip_contents t u Hshape)))
    {T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B, C: Type
t: T A
u: T B
f: A * B -> G C
Hshape: shape t = shape u
H1: trav_make (same_shape_zip t u Hshape) ~!~
trav_make t
H2: trav_contents (same_shape_zip t u Hshape) ~~
same_shape_zip_contents t u Hshape
map (trav_make (same_shape_zip t u Hshape))
  (forwards
     (traverse (mkBackwards ∘ f)
        (trav_contents (same_shape_zip t u Hshape)))) =
map (trav_make t)
  (forwards
     (traverse (mkBackwards ∘ f)
        (same_shape_zip_contents t u Hshape))) compose near (traverse (mkBackwards ∘ f) (trav_contents (same_shape_zip t u Hshape))).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B, C: Type
t: T A
u: T B
f: A * B -> G C
Hshape: shape t = shape u
H1: trav_make (same_shape_zip t u Hshape) ~!~
trav_make t
H2: trav_contents (same_shape_zip t u Hshape) ~~
same_shape_zip_contents t u Hshape
(map (trav_make (same_shape_zip t u Hshape))
 ∘ forwards)
  (traverse (mkBackwards ∘ f)
     (trav_contents (same_shape_zip t u Hshape))) =
map (trav_make t)
  (forwards
     (traverse (mkBackwards ∘ f)
        (same_shape_zip_contents t u Hshape)))
      compose near (traverse (mkBackwards ∘ f) (same_shape_zip_contents t u Hshape)).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B, C: Type
t: T A
u: T B
f: A * B -> G C
Hshape: shape t = shape u
H1: trav_make (same_shape_zip t u Hshape) ~!~
trav_make t
H2: trav_contents (same_shape_zip t u Hshape) ~~
same_shape_zip_contents t u Hshape
(map (trav_make (same_shape_zip t u Hshape))
 ∘ forwards)
  (traverse (mkBackwards ∘ f)
     (trav_contents (same_shape_zip t u Hshape))) =
(map (trav_make t) ∘ forwards)
  (traverse (mkBackwards ∘ f)
     (same_shape_zip_contents t u Hshape))
      rewrite natural.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B, C: Type
t: T A
u: T B
f: A * B -> G C
Hshape: shape t = shape u
H1: trav_make (same_shape_zip t u Hshape) ~!~
trav_make t
H2: trav_contents (same_shape_zip t u Hshape) ~~
same_shape_zip_contents t u Hshape
(forwards
 ∘ map (trav_make (same_shape_zip t u Hshape)))
  (traverse (mkBackwards ∘ f)
     (trav_contents (same_shape_zip t u Hshape))) =
(map (trav_make t) ∘ forwards)
  (traverse (mkBackwards ∘ f)
     (same_shape_zip_contents t u Hshape))
      rewrite natural.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B, C: Type
t: T A
u: T B
f: A * B -> G C
Hshape: shape t = shape u
H1: trav_make (same_shape_zip t u Hshape) ~!~
trav_make t
H2: trav_contents (same_shape_zip t u Hshape) ~~
same_shape_zip_contents t u Hshape
(forwards
 ∘ map (trav_make (same_shape_zip t u Hshape)))
  (traverse (mkBackwards ∘ f)
     (trav_contents (same_shape_zip t u Hshape))) =
(forwards ∘ map (trav_make t))
  (traverse (mkBackwards ∘ f)
     (same_shape_zip_contents t u Hshape))
      unfold compose.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B, C: Type
t: T A
u: T B
f: A * B -> G C
Hshape: shape t = shape u
H1: trav_make (same_shape_zip t u Hshape) ~!~
trav_make t
H2: trav_contents (same_shape_zip t u Hshape) ~~
same_shape_zip_contents t u Hshape
forwards
  (map (trav_make (same_shape_zip t u Hshape))
     (traverse (mkBackwards ○ f)
        (trav_contents (same_shape_zip t u Hshape)))) =
forwards
  (map (trav_make t)
     (traverse (mkBackwards ○ f)
        (same_shape_zip_contents t u Hshape)))
      fequal.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B, C: Type
t: T A
u: T B
f: A * B -> G C
Hshape: shape t = shape u
H1: trav_make (same_shape_zip t u Hshape) ~!~
trav_make t
H2: trav_contents (same_shape_zip t u Hshape) ~~
same_shape_zip_contents t u Hshape
map (trav_make (same_shape_zip t u Hshape))
  (traverse (mkBackwards ○ f)
     (trav_contents (same_shape_zip t u Hshape))) =
map (trav_make t)
  (traverse (mkBackwards ○ f)
     (same_shape_zip_contents t u Hshape))
      apply map_sim_fns; auto.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
G: Type -> Type
Map_G: Map G
Pure_G: Pure G
Mult_G: Mult G
H0: Applicative G
A, B, C: Type
t: T A
u: T B
f: A * B -> G C
Hshape: shape t = shape u
H1: trav_make (same_shape_zip t u Hshape) ~!~
trav_make t
H2: trav_contents (same_shape_zip t u Hshape) ~~
same_shape_zip_contents t u Hshape
Applicative (Backwards G)
      typeclasses eauto.
    }
  Qed.

  Instance ApplicativeMorphism_const_op `{op: Monoid_op M} `{unit: Monoid_unit M} `{! Monoid M}:
    @ApplicativeMorphism (@const Type Type M) (Backwards (@const Type Type M))
      (@Map_const M) (@Mult_const M (@Monoid_op_Opposite M op)) (@Pure_const M unit)
      (@Map_Backwards (const M) _) (@Mult_Backwards (const M) (@Map_const M) (@Mult_const M op))
      (@Pure_Backwards (const M) (@Pure_const M unit)) (@mkBackwards (const M)).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
M: Type
op: Monoid_op M
unit: Monoid_unit M
Monoid0: Monoid M
ApplicativeMorphism (const M) (Backwards (const M))
  (@mkBackwards (const M))
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
M: Type
op: Monoid_op M
unit: Monoid_unit M
Monoid0: Monoid M
ApplicativeMorphism (const M) (Backwards (const M))
  (@mkBackwards (const M))
    constructor; try typeclasses eauto.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
M: Type
op: Monoid_op M
unit: Monoid_unit M
Monoid0: Monoid M
forall (A B : Type) (f : A -> B) (x : const M A),
{| forwards := map f x |} = map f {| forwards := x |}
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
M: Type
op: Monoid_op M
unit: Monoid_unit M
Monoid0: Monoid M
forall (A : Type) (a : A),
{| forwards := pure a |} = pure a
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
M: Type
op: Monoid_op M
unit: Monoid_unit M
Monoid0: Monoid M
forall (A B : Type) (x : const M A) (y : const M B),
{| forwards := x ⊗ y |} =
{| forwards := x |} ⊗ {| forwards := y |}
    -T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
M: Type
op: Monoid_op M
unit: Monoid_unit M
Monoid0: Monoid M
forall (A B : Type) (f : A -> B) (x : const M A),
{| forwards := map f x |} = map f {| forwards := x |} reflexivity.
    -T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
M: Type
op: Monoid_op M
unit: Monoid_unit M
Monoid0: Monoid M
forall (A : Type) (a : A),
{| forwards := pure a |} = pure a reflexivity.
    -T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
M: Type
op: Monoid_op M
unit: Monoid_unit M
Monoid0: Monoid M
forall (A B : Type) (x : const M A) (y : const M B),
{| forwards := x ⊗ y |} =
{| forwards := x |} ⊗ {| forwards := y |} reflexivity.
  Qed.

  Instance ApplicativeMorphism_const_op_inv `{op: Monoid_op M} `{unit: Monoid_unit M} `{! Monoid M}:
    @ApplicativeMorphism (Backwards (@const Type Type M))(@const Type Type M)
      (@Map_Backwards (const M) _) (@Mult_Backwards (const M) (@Map_const M) (@Mult_const M op))
      (@Pure_Backwards (const M) (@Pure_const M unit))
      (@Map_const M) (@Mult_const M (@Monoid_op_Opposite M op)) (@Pure_const M unit)
      (@forwards (const M)).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
M: Type
op: Monoid_op M
unit: Monoid_unit M
Monoid0: Monoid M
ApplicativeMorphism (Backwards (const M)) (const M)
  (@forwards (const M))
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
M: Type
op: Monoid_op M
unit: Monoid_unit M
Monoid0: Monoid M
ApplicativeMorphism (Backwards (const M)) (const M)
  (@forwards (const M))
    constructor; try typeclasses eauto.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
M: Type
op: Monoid_op M
unit: Monoid_unit M
Monoid0: Monoid M
forall (A B : Type) (f : A -> B)
  (x : Backwards (const M) A),
forwards (map f x) = map f (forwards x)
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
M: Type
op: Monoid_op M
unit: Monoid_unit M
Monoid0: Monoid M
forall (A : Type) (a : A), forwards (pure a) = pure a
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
M: Type
op: Monoid_op M
unit: Monoid_unit M
Monoid0: Monoid M
forall (A B : Type) (x : Backwards (const M) A)
  (y : Backwards (const M) B),
forwards (x ⊗ y) = forwards x ⊗ forwards y
    -T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
M: Type
op: Monoid_op M
unit: Monoid_unit M
Monoid0: Monoid M
forall (A B : Type) (f : A -> B)
  (x : Backwards (const M) A),
forwards (map f x) = map f (forwards x) reflexivity.
    -T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
M: Type
op: Monoid_op M
unit: Monoid_unit M
Monoid0: Monoid M
forall (A : Type) (a : A), forwards (pure a) = pure a reflexivity.
    -T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
M: Type
op: Monoid_op M
unit: Monoid_unit M
Monoid0: Monoid M
forall (A B : Type) (x : Backwards (const M) A)
  (y : Backwards (const M) B),
forwards (x ⊗ y) = forwards x ⊗ forwards y reflexivity.
  Qed.

  Definition foldmap_same_shape_zip
    `{Monoid M}
    (A B C: Type) (t: T A) (u: T B)
    (f: A * B -> M)
    (Hshape: shape t = shape u)
    :
    mapReduce f (same_shape_zip t u Hshape) =
      mapReduce (op := Monoid_op_Opposite op) f (same_shape_zip_contents t u Hshape).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
M: Type
op: Monoid_op M
unit0: Monoid_unit M
H0: Monoid M
A, B, C: Type
t: T A
u: T B
f: A * B -> M
Hshape: shape t = shape u
mapReduce f (same_shape_zip t u Hshape) =
mapReduce f (same_shape_zip_contents t u Hshape)
  Proof.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
M: Type
op: Monoid_op M
unit0: Monoid_unit M
H0: Monoid M
A, B, C: Type
t: T A
u: T B
f: A * B -> M
Hshape: shape t = shape u
mapReduce f (same_shape_zip t u Hshape) =
mapReduce f (same_shape_zip_contents t u Hshape)
    intros.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
M: Type
op: Monoid_op M
unit0: Monoid_unit M
H0: Monoid M
A, B, C: Type
t: T A
u: T B
f: A * B -> M
Hshape: shape t = shape u
mapReduce f (same_shape_zip t u Hshape) =
mapReduce f (same_shape_zip_contents t u Hshape)
    rewrite mapReduce_to_traverse1.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
M: Type
op: Monoid_op M
unit0: Monoid_unit M
H0: Monoid M
A, B, C: Type
t: T A
u: T B
f: A * B -> M
Hshape: shape t = shape u
traverse f (same_shape_zip t u Hshape) =
mapReduce f (same_shape_zip_contents t u Hshape)
    rewrite traverse_same_shape_zip.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
M: Type
op: Monoid_op M
unit0: Monoid_unit M
H0: Monoid M
A, B, C: Type
t: T A
u: T B
f: A * B -> M
Hshape: shape t = shape u
map (trav_make t)
  (forwards
     (traverse (mkBackwards ∘ f)
        (same_shape_zip_contents t u Hshape))) =
mapReduce f (same_shape_zip_contents t u Hshape)
    rewrite mapReduce_to_traverse1.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
M: Type
op: Monoid_op M
unit0: Monoid_unit M
H0: Monoid M
A, B, C: Type
t: T A
u: T B
f: A * B -> M
Hshape: shape t = shape u
map (trav_make t)
  (forwards
     (traverse (mkBackwards ∘ f)
        (same_shape_zip_contents t u Hshape))) =
traverse f (same_shape_zip_contents t u Hshape)
    unfold_ops @Map_const.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
M: Type
op: Monoid_op M
unit0: Monoid_unit M
H0: Monoid M
A, B, C: Type
t: T A
u: T B
f: A * B -> M
Hshape: shape t = shape u
forwards
  (traverse (mkBackwards ∘ f)
     (same_shape_zip_contents t u Hshape)) =
traverse f (same_shape_zip_contents t u Hshape)
    compose near (same_shape_zip_contents t u Hshape) on left.T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
M: Type
op: Monoid_op M
unit0: Monoid_unit M
H0: Monoid M
A, B, C: Type
t: T A
u: T B
f: A * B -> M
Hshape: shape t = shape u
(forwards ∘ traverse (mkBackwards ∘ f))
  (same_shape_zip_contents t u Hshape) =
traverse f (same_shape_zip_contents t u Hshape)
    change ((fun (X Y : Type) (_ : X -> Y) (t0 : @const Type Type M X) => t0))
             with (@Map_const M).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
M: Type
op: Monoid_op M
unit0: Monoid_unit M
H0: Monoid M
A, B, C: Type
t: T A
u: T B
f: A * B -> M
Hshape: shape t = shape u
(forwards ∘ traverse (mkBackwards ∘ f))
  (same_shape_zip_contents t u Hshape) =
traverse f (same_shape_zip_contents t u Hshape)
    rewrite (trf_traverse_morphism (T := Vector (@plength T Traverse_T A t))
               (morphism := ApplicativeMorphism_const_op_inv (M := M))).T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToSubset_inst: ToSubset T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToSubset_Traverse0: Compat_ToSubset_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
M: Type
op: Monoid_op M
unit0: Monoid_unit M
H0: Monoid M
A, B, C: Type
t: T A
u: T B
f: A * B -> M
Hshape: shape t = shape u
traverse (forwards ∘ (mkBackwards ∘ f))
  (same_shape_zip_contents t u Hshape) =
traverse f (same_shape_zip_contents t u Hshape)
    reflexivity.
  Qed.

  (*
  Lemma traverse_const_opposite `{Monoid M} {A B: Type} (f: A -> M):
    traverse (T := T) (G := const M)
      (@Mult_const M (@Monoid_op_Opposite M op))

    Search traverse same_shape_zip_contents.
    rewrite t
              .
    unfold mapReduce.
    rewrite traverse_same_shape_zip.
    rewrite <- traverse_repr.
    rewrite traverse_same_shape_zip.

    reflexivity.
  Qed.

   *)
End traversable_functors_zipping.


(** ** Folding over a Vector of pairs *)
(**********************************************************************)
Section fold_over_vector_pairs.

  Context {A B A0 B0: Type} `{Monoid M} `(f: A * B -> M).

  Lemma mapReduce_vector_pair_natural:
    forall (fl: A0 -> A) (fr: B0 -> B),
    forall (n: nat) (v: Vector n (A0 * B0)),
      mapReduce (T := Vector n) f (map (F := Vector n) (map_tensor fl fr) v) =
        mapReduce (T := Vector n) (f ∘ map_tensor fl fr) v.A, B, A0, B0, M: Type
op: Monoid_op M
unit0: Monoid_unit M
H: Monoid M
f: A * B -> M
forall (fl : A0 -> A) (fr : B0 -> B) (n : nat)
  (v : Vector n (A0 * B0)),
mapReduce f (map (map_tensor fl fr) v) =
mapReduce (f ∘ map_tensor fl fr) v
  Proof.A, B, A0, B0, M: Type
op: Monoid_op M
unit0: Monoid_unit M
H: Monoid M
f: A * B -> M
forall (fl : A0 -> A) (fr : B0 -> B) (n : nat)
  (v : Vector n (A0 * B0)),
mapReduce f (map (map_tensor fl fr) v) =
mapReduce (f ∘ map_tensor fl fr) v
    intros.A, B, A0, B0, M: Type
op: Monoid_op M
unit0: Monoid_unit M
H: Monoid M
f: A * B -> M
fl: A0 -> A
fr: B0 -> B
n: nat
v: Vector n (A0 * B0)
mapReduce f (map (map_tensor fl fr) v) =
mapReduce (f ∘ map_tensor fl fr) v
    compose near v on left.A, B, A0, B0, M: Type
op: Monoid_op M
unit0: Monoid_unit M
H: Monoid M
f: A * B -> M
fl: A0 -> A
fr: B0 -> B
n: nat
v: Vector n (A0 * B0)
(mapReduce f ∘ map (map_tensor fl fr)) v =
mapReduce (f ∘ map_tensor fl fr) v
    rewrite mapReduce_map.A, B, A0, B0, M: Type
op: Monoid_op M
unit0: Monoid_unit M
H: Monoid M
f: A * B -> M
fl: A0 -> A
fr: B0 -> B
n: nat
v: Vector n (A0 * B0)
mapReduce (f ∘ map_tensor fl fr) v =
mapReduce (f ∘ map_tensor fl fr) v
    reflexivity.
  Qed.

  Lemma mapReduce_vector_pair_natural_l:
    forall (fl: A0 -> A) (n: nat) (v: Vector n (A0 * B)),
      mapReduce (T := Vector n) f (map (F := Vector n) (map_fst fl) v) =
        mapReduce (T := Vector n) (f ∘ map_fst fl) v.A, B, A0, B0, M: Type
op: Monoid_op M
unit0: Monoid_unit M
H: Monoid M
f: A * B -> M
forall (fl : A0 -> A) (n : nat)
  (v : Vector n (A0 * B)),
mapReduce f (map (map_fst fl) v) =
mapReduce (f ∘ map_fst fl) v
  Proof.A, B, A0, B0, M: Type
op: Monoid_op M
unit0: Monoid_unit M
H: Monoid M
f: A * B -> M
forall (fl : A0 -> A) (n : nat)
  (v : Vector n (A0 * B)),
mapReduce f (map (map_fst fl) v) =
mapReduce (f ∘ map_fst fl) v
    intros.A, B, A0, B0, M: Type
op: Monoid_op M
unit0: Monoid_unit M
H: Monoid M
f: A * B -> M
fl: A0 -> A
n: nat
v: Vector n (A0 * B)
mapReduce f (map (map_fst fl) v) =
mapReduce (f ∘ map_fst fl) v
    compose near v on left.A, B, A0, B0, M: Type
op: Monoid_op M
unit0: Monoid_unit M
H: Monoid M
f: A * B -> M
fl: A0 -> A
n: nat
v: Vector n (A0 * B)
(mapReduce f ∘ map (map_fst fl)) v =
mapReduce (f ∘ map_fst fl) v
    rewrite mapReduce_map.A, B, A0, B0, M: Type
op: Monoid_op M
unit0: Monoid_unit M
H: Monoid M
f: A * B -> M
fl: A0 -> A
n: nat
v: Vector n (A0 * B)
mapReduce (f ∘ map_fst fl) v =
mapReduce (f ∘ map_fst fl) v
    reflexivity.
  Qed.

  Lemma mapReduce_vector_pair_natural_r:
    forall (fr: B0 -> B) (n: nat) (v: Vector n (A * B0)),
      mapReduce (T := Vector n) f (map (F := Vector n) (map_snd fr) v) =
        mapReduce (T := Vector n) (f ∘ map_snd fr) v.A, B, A0, B0, M: Type
op: Monoid_op M
unit0: Monoid_unit M
H: Monoid M
f: A * B -> M
forall (fr : B0 -> B) (n : nat)
  (v : Vector n (A * B0)),
mapReduce f (map (map_snd fr) v) =
mapReduce (f ∘ map_snd fr) v
  Proof.A, B, A0, B0, M: Type
op: Monoid_op M
unit0: Monoid_unit M
H: Monoid M
f: A * B -> M
forall (fr : B0 -> B) (n : nat)
  (v : Vector n (A * B0)),
mapReduce f (map (map_snd fr) v) =
mapReduce (f ∘ map_snd fr) v
    intros.A, B, A0, B0, M: Type
op: Monoid_op M
unit0: Monoid_unit M
H: Monoid M
f: A * B -> M
fr: B0 -> B
n: nat
v: Vector n (A * B0)
mapReduce f (map (map_snd fr) v) =
mapReduce (f ∘ map_snd fr) v
    compose near v on left.A, B, A0, B0, M: Type
op: Monoid_op M
unit0: Monoid_unit M
H: Monoid M
f: A * B -> M
fr: B0 -> B
n: nat
v: Vector n (A * B0)
(mapReduce f ∘ map (map_snd fr)) v =
mapReduce (f ∘ map_snd fr) v
    rewrite mapReduce_map.A, B, A0, B0, M: Type
op: Monoid_op M
unit0: Monoid_unit M
H: Monoid M
f: A * B -> M
fr: B0 -> B
n: nat
v: Vector n (A * B0)
mapReduce (f ∘ map_snd fr) v =
mapReduce (f ∘ map_snd fr) v
    reflexivity.
  Qed.

End fold_over_vector_pairs.

(** * Uniqueness *)
(**********************************************************************)

Section uniqueness_lemmas.

  Context {A B: Type}.

  Context
    `{Classes.Kleisli.TraversableFunctor.TraversableFunctor T}
    `{ToMap_inst: Map T}
    `{ToBatch_inst: ToBatch T}
    `{! Compat_Map_Traverse T}
    `{! Compat_ToBatch_Traverse T}.

  Lemma trav_contents_unique:
    forall (t: T A) (u: T B) (v: Vector (plength t) B),
      trav_make t v = u -> v ~~ trav_contents u.A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (t : T A) (u : T B) (v : Vector (plength t) B),
trav_make t v = u -> v ~~ trav_contents u
  Proof.A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (t : T A) (u : T B) (v : Vector (plength t) B),
trav_make t v = u -> v ~~ trav_contents u
    introv Hmake.A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
t: T A
u: T B
v: Vector (plength t) B
Hmake: trav_make t v = u
v ~~ trav_contents u
    rewrite <- Hmake.A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
t: T A
u: T B
v: Vector (plength t) B
Hmake: trav_make t v = u
v ~~ trav_contents (trav_make t v)
    unfold Vector_sim.A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
t: T A
u: T B
v: Vector (plength t) B
Hmake: trav_make t v = u
proj1_sig v =
proj1_sig (trav_contents (trav_make t v))
    rewrite trav_contents_make.A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
t: T A
u: T B
v: Vector (plength t) B
Hmake: trav_make t v = u
proj1_sig v = proj1_sig v
    reflexivity.
  Qed.

  Lemma trav_make_unique:
    forall (t: T A) (u: T B) (v: Vector (plength t) B),
      trav_make t v = u ->
      forall (C: Type), trav_make (B := C) t ~!~ trav_make u.A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (t : T A) (u : T B) (v : Vector (plength t) B),
trav_make t v = u ->
forall C : Type, trav_make t ~!~ trav_make u
  Proof.A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (t : T A) (u : T B) (v : Vector (plength t) B),
trav_make t v = u ->
forall C : Type, trav_make t ~!~ trav_make u
    introv Hmake.A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
t: T A
u: T B
v: Vector (plength t) B
Hmake: trav_make t v = u
forall C : Type, trav_make t ~!~ trav_make u intro C.A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
t: T A
u: T B
v: Vector (plength t) B
Hmake: trav_make t v = u
C: Type
trav_make t ~!~ trav_make u
    rewrite <- Hmake.A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
t: T A
u: T B
v: Vector (plength t) B
Hmake: trav_make t v = u
C: Type
trav_make t ~!~ trav_make (trav_make t v)
    rewrite symmetric_Vector_fun_sim.A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
t: T A
u: T B
v: Vector (plength t) B
Hmake: trav_make t v = u
C: Type
trav_make (trav_make t v) ~!~ trav_make t
    apply trav_make_make.
  Qed.

  Corollary trav_decomposition_unique:
    forall (t: T A) (u: T B) (v: Vector (plength t) B),
      trav_make t v = u ->
      (forall C, trav_make (B := C) t ~!~ trav_make u) /\
        v ~~ trav_contents u.A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (t : T A) (u : T B) (v : Vector (plength t) B),
trav_make t v = u ->
(forall C : Type, trav_make t ~!~ trav_make u) /\
v ~~ trav_contents u
  Proof.A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (t : T A) (u : T B) (v : Vector (plength t) B),
trav_make t v = u ->
(forall C : Type, trav_make t ~!~ trav_make u) /\
v ~~ trav_contents u
    introv Hmake; split.A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
t: T A
u: T B
v: Vector (plength t) B
Hmake: trav_make t v = u
forall C : Type, trav_make t ~!~ trav_make u
A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
t: T A
u: T B
v: Vector (plength t) B
Hmake: trav_make t v = u
v ~~ trav_contents u
    eauto using trav_make_unique.A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
t: T A
u: T B
v: Vector (plength t) B
Hmake: trav_make t v = u
v ~~ trav_contents u
    auto using trav_contents_unique.
  Qed.


  Corollary trav_decomposition_unique_iff:
    forall (t: T A) (u: T B) (v: Vector (plength t) B),
      trav_make t v = u <->
        (forall C, trav_make (B := C) t ~!~ trav_make u) /\
          v ~~ trav_contents u.A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (t : T A) (u : T B) (v : Vector (plength t) B),
trav_make t v = u <->
(forall C : Type, trav_make t ~!~ trav_make u) /\
v ~~ trav_contents u
  Proof.A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (t : T A) (u : T B) (v : Vector (plength t) B),
trav_make t v = u <->
(forall C : Type, trav_make t ~!~ trav_make u) /\
v ~~ trav_contents u
    intros.A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
t: T A
u: T B
v: Vector (plength t) B
trav_make t v = u <->
(forall C : Type, trav_make t ~!~ trav_make u) /\
v ~~ trav_contents u split.A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
t: T A
u: T B
v: Vector (plength t) B
trav_make t v = u ->
(forall C : Type, trav_make t ~!~ trav_make u) /\
v ~~ trav_contents u
A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
t: T A
u: T B
v: Vector (plength t) B
(forall C : Type, trav_make t ~!~ trav_make u) /\
v ~~ trav_contents u -> 
trav_make t v = u
    -A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
t: T A
u: T B
v: Vector (plength t) B
trav_make t v = u ->
(forall C : Type, trav_make t ~!~ trav_make u) /\
v ~~ trav_contents u apply trav_decomposition_unique.
    -A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
t: T A
u: T B
v: Vector (plength t) B
(forall C : Type, trav_make t ~!~ trav_make u) /\
v ~~ trav_contents u -> trav_make t v = u intros [Hmake Hcontents].A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
t: T A
u: T B
v: Vector (plength t) B
Hmake: forall C : Type, trav_make t ~!~ trav_make u
Hcontents: v ~~ trav_contents u
trav_make t v = u
      rewrite <- (trav_get_put (t := u)).A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
t: T A
u: T B
v: Vector (plength t) B
Hmake: forall C : Type, trav_make t ~!~ trav_make u
Hcontents: v ~~ trav_contents u
trav_make t v = trav_make u (trav_contents u)
      apply Vector_fun_sim_eq; auto.
  Qed.

  Corollary trav_decomposition_same_shape:
    forall (t: T A) (u: T B) (v: Vector (plength t) B),
      trav_make t v = u ->
      shape t = shape u.A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (t : T A) (u : T B) (v : Vector (plength t) B),
trav_make t v = u -> shape t = shape u
  Proof.A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (t : T A) (u : T B) (v : Vector (plength t) B),
trav_make t v = u -> shape t = shape u
    introv Hmake.A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
t: T A
u: T B
v: Vector (plength t) B
Hmake: trav_make t v = u
shape t = shape u
    apply trav_same_shape_rev.A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
t: T A
u: T B
v: Vector (plength t) B
Hmake: trav_make t v = u
forall B0 : Type, trav_make t ~!~ trav_make u
    eapply trav_make_unique.A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
t: T A
u: T B
v: Vector (plength t) B
Hmake: trav_make t v = u
trav_make t ?v = u
    eassumption.
  Qed.

  Corollary trav_decomposition_same_length:
    forall (t: T A) (u: T B) (v: Vector (plength t) B),
      trav_make t v = u ->
      plength t = plength u.A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (t : T A) (u : T B) (v : Vector (plength t) B),
trav_make t v = u -> plength t = plength u
  Proof.A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
forall (t : T A) (u : T B) (v : Vector (plength t) B),
trav_make t v = u -> plength t = plength u
    introv Hmake.A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
t: T A
u: T B
v: Vector (plength t) B
Hmake: trav_make t v = u
plength t = plength u
    apply same_shape_implies_plength.A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
t: T A
u: T B
v: Vector (plength t) B
Hmake: trav_make t v = u
shape t = shape u
    eapply trav_decomposition_same_shape.A, B: Type
T: Type -> Type
Traverse_T: Traverse T
H: TraversableFunctor T
ToMap_inst: Map T
ToBatch_inst: ToBatch T
Compat_Map_Traverse0: Compat_Map_Traverse T
Compat_ToBatch_Traverse0: Compat_ToBatch_Traverse T
t: T A
u: T B
v: Vector (plength t) B
Hmake: trav_make t v = u
trav_make t ?v = u
    eassumption.
  Qed.

End uniqueness_lemmas.