(** # #
#+TITLE: cartierSolution9.v

Proph

https://gitlab.com/1337777/cartier/blob/master/cartierSolution9.v

solves half of some question of CARTIER which is how to program « parametrization modos » ( "parametrized form" , "dependent type" , "fibration with internal products" ) ...

ERRATA :: this also solves cartierSolution8.v where the continuity-property was "confused" .

SHORT ::

  (1.) The ends is « QOC » : to program the « form-morphisms » parametrized-over the « parametrizator-arrows » ( "fibration" ) , which are generated by some « generating » parametrization-functor , such that this programming enables the computational-logical introductions-eliminations constructors and the cut/pullback-elimination/admissibility lemmas when in the presence of the grammatical « product/pi-objects » or the grammatical « substitution-objects » or the grammatical « colimit/sum/sigma/viewingfunctor-objects » ; and to do this programming coherently/continuously for the viewing-data/topology sense-decodings .

  (2.) Commonly , the "lambda calculus" has the « cancellation » computation [  ( ( application s ) <o ( abstraction f ) )  :=  substitution ( f , s )  ] , where [ f ] is some function and [ s ] is some element ; but now in contrast the input function [ f ] (transformation function from representable/generator functor into the product-object/functor) shall be viewed as parametrized-over the given/fixed context-projection function (which defines the product-object) whose input section [ s ] is some now-function which parametrizes its corresponding application function [ application s ] and also parametrizes the output function [ substitution ( f , s ) ] of the substitution operation .

  (3.) In other words , given any grammatical form-morphism [ f ] of [  |-  ( E ~> F )  ] parametrized-over the parametrizator-arrow ( "span" ) [  project <o> subst  ] , whose sensible-decoding is some « formatted » function [  project* E  |-  subst* F  ] across the « formats » ( "pullbacks" ) from [  project* E  ] to [  subst* F  ] parametrized-over the (elements of the) parametrizator-object (metafunctor over the generator-morphology not the generating-parametrizator-morphology) [ P ] , oneself shall :
    (3.1.) introduce some grammatical product/pi-object ( really « pi-substitution » ) with « inner-parametrizing/pairing/tupling/abstraction/remembering » ( reparametrized ) morphism [  |-  ( E ~> PI_project SUBST_subst F )  ] which is polymorph-laxly-cancelled by the ( « selection/application/forgetting » ) morphism [  |-  ( PI_project SUBST_subst F ~> F )  ] corresponding to some section arrow [ section ] of the [ project ] arrow ,
    (3.2.) or introduce some grammatical substitution-object with « remembering » morphism [  |-  ( E ~> SUBST_subst F )  ] which is polymorph-(tightly-)cancelled by the « forgetting » morphism [  |-  ( SUBST_subst F ~> F )  ] of the substitution-object , for the instances when the [ project ] arrow is identity ,
    (3.3.) and do such coherently/continuously for the viewing-data/topology sense-decodings which are internalized ( when finite-compact or finite-dimensional or finite-generated ) via the elimination of the (parametrized-and-modified) grammatical colimiting/sum/sigma/viewingfunctor-objects ( parametrized-and-modified rephrasing of « each functor is the sum/colimit of its elements » ) : [  X ; (p : P X) ; (e : E X (project p))  |-  F X (subst p)  ] ,
    (3.4.) where the grammar definition/lemma and the cut/pullback-elimination/admissibility lemma/definition ( and the decidability of unification/convertibility , and the commutation of format/substitution along pi-substitution , and the analogue between "localization of fibration" and  « programming locally after non-empty global contexts » , and the intended "cartesian" properties , and the non-necessity of "discrete-fibration" properties , and the limit-exactness/preservation of the viewed-functor construction which is used to add/express such things as « viewed-substitution » or « viewed-pi-substitution » ) are interdependently-discovered by many refinements after many attempts .

  (4.) Another angle of view :

#+BEGIN_EXAMPLE
E ---------------------- f ----------------------> F
|                                                  |
. PI_project SUBST_subst F ---- application _ ---> .
|  |                                               |
.  .                                               .
|  |                                               |
.  .                                               .
|  v                                               |
v ------- section ------->                         v
E_ <----- project ------- P ------- subst -------> F_
#+END_EXAMPLE

  (5.) Memo that this polymorph presentation of the pi-substitution objects has pre-substitution by any accumulator parametrizator-morphism built-in grammatically , therefore this infers the commutation of format/substitution along pi-substitution : [  t* PI_p SUBST_s  (grammatically via parametrizator-object)  <->  PI_p SUBST_(t o> s)  (grammatically via form-object)  ] .

  (6.) Memo that any parametrizator-morphism ( "span" ) [ l <o> r ] may be viewed as some function [ r ] whose domain has been reindexed by the function [ l ] , and the composition of two parametrizator-morphisms ( "spans" ) is similar as some « polymorph pullback » ; therefore the grammatical cut-elimination/admissibility for such parametrizator-morphisms is in fact similar as some « polymorph-pullback-elimination/admissibility » which says that the pullback process among parametrizator-morphisms shall be structured/grammatical and not-merely exist in the sense .

  (7.) Moreover memo that the form-morphisms parametrized-over the parametrizator-morphisms are defined « mutually inductively » with the parametrizator-morphisms , which says that , in adddition of doing « selection/application/forgetting » ( "lifting-as-identity" ) from any parametrizator-morphism upto the selection/application/forgetting-morphism of the pi/substitution-object , moreover oneself may do « formatting » ( "context extension" by any form-morphism , beyond the common "context extension" by own lifting ) from any form-morphism downto some parametrizator-morphism .
  Regardless , any generating parametrization-functor which is « sense-discrete » ( "discrete-fibration" with only selection/application/forgetting-morphisms , which are really "lifting-as-identity" ) would be simpler because then only « nested-mutual induction » is required by the absence ( non-necessity ) of this formatting constructor ( "context extension" by any form-morphism ) .
  Regardless , any generating parametrization-functor which is (constructively) « full functor » would be simpler because then any element of some parametrizator-object (element of metafunctor over the generator-morphology not the generating-parametrizator-morphology) has some fixed-chosen extension as polyelement (metatransformation) .

  (8.) In summary , the final expressivity shall allow these two things ( II.8.5.5 ) : (1) mutual induction of form-morphisms with parametrizator-morphisms via the presence of the « formatting » constructor , (2) programming locally after « non-empty global contexts » . For (1) , therefore some grammatical pullback-elimination/admissibility for the form-morphisms shall also be necessary , in particular the "fibre-completeness" of the generating parametrization-functor shall be necessary . For (2) , the mathematician counter-part of this engineer-programmer "feature" is named « localization of fibration at some object of the base » . Regardless , everything can always be compiled back to the empty global context ( II.8.5.9 ) ...

  (9.) Memo that this presentation of the pi/substitution-objects is « cartesian » only when the domain of the inner-parametrizing/pairing/tupling/abstraction/remembering-morphism is some generator (representable-functor) . This ( intended , as in the lambda calculus ) limitation can be erased in the case when the generating parametrization-functor is « sense-discrete » , where the parametrizator-morphisms are nested within the form-morphisms and are therefore priorly decidable .

  (10.) Finally , memo that the grammatical colimiting/sum/sigma/viewing-functor-objects assume some finiteness properties ( such as finite-compactness or finite-dimensionality or finite-generated ) onto the viewing-data/topology sense-decodings which they internalize . And these viewing-functor-objects are similar as generators ( representable-functors ) but to be used for functors which are already viewed-functors ( "sheaf" ) . Therefore , and knowning that the viewed-functor construction is exact and commutes with limits ,  oneself may add/express such things as « viewed-substitution » or « viewed-pi-substitution » , as long as the codomain is already some viewed-functor and the domain for the « cartesian » property is now some viewing-functor .
  Regardless , eventually the product/pi-objects shall assume similar finiteness properties , in the style of the « compacted-point » technique ( "compact-open topology for the compactly-continuous mappings , which gives compactly-uniform convergence" ( II.7.4.10 )  ...  « compacted-parameters compacted-arguments viewing-data for the compacted-viewing-continuous morphisms » ? ) .

  (11.) For instant first impression , the conversion/computation-relation constructor which says that the « forgetting » morphism of the substitution-object polymorph-cancels the « remembering » morphism corresponding to any form-morphism , is written as :

#+BEGIN_EXAMPLE
| Remember_Forget :  forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F
 Yoneda01_Param_F Yoneda10_FormParam_F (F : obCoMod Yoneda10_FormParam_F)
 (Param_F : obCoMod_Param Yoneda01_Param_F) Yoneda00_Param_SubstF
 Yoneda01_Param_SubstF (Param_SubstF : obCoMod_Param Yoneda01_Param_SubstF)
 Yoneda10_Param_Forget (param_Forget :
 'CoMod_( Param_SubstF ~> Param_F @_ Yoneda10_Param_Forget ))
 (L : obGenerator) Yoneda10_Param_ll Yoneda10_Form_ll
 (ll : 'CoMod( View L ~> F @_ Yoneda10_Param_ll @^ Yoneda10_Form_ll ))
 Yoneda10_Param_ll_ , (* ... *)

 ( ll o>CoMod ee )
 <~~ ( << ll @_ Heq_param = Yoneda10_Param_ll_ , Heq_subst_0 = param_Forget_0 >>
           : 'CoMod ( View L ~> _ @_ _ @^ _ ) )
     o>CoMod ( ( 'Forget @_ Heq_subst = param_Forget o>CoMod ee )
 : 'CoMod( Subst F Param_F Param_SubstF Yoneda10_Param_Forget' ~> E @_ _ @^ _ ) )
#+END_EXAMPLE

KEYWORDS :: OOO1337777 ; COQ ; QOC ; MODOS

OUTLINE ::

  * Generating parametrization-functor metalogic
    + Generating parameters
    + Generating parametrized-forms

  * Grammatical presentation of objects
    + Sense-decodings of the objects
    + Finiteness of the viewing-elements of some viewing-functor
    + Grammar of the objects , which carry the sense-decodings

  * Grammatical presentation of morphisms
    + Sense-decodings of the morphisms
    + Grammar of the morphisms , which carry the sense-decodings

  * Grammatical conversions of morphisms , which infer the same sense-decoding
    + Grammatical conversions of morphisms
    + Same sense-decoding for convertible morphisms
    + Linear total/asymptotic grade and the degradation lemma

  * Solution morphisms
    + Solution morphisms without polymorphism
    + Destruction of morphisms with inner-instantiation of object-indexes

  * Polymorphism/cut-elimination by computational/total/asymptotic/reduction/(multi-step) resolution

HINT :: do cartierSolution10.v cartierSolution11.v

-----

* Generating parametrization-functor metalogic

** Generating parameters

  In contrast , there are two generating morphologies . Firstly , the "base" generating morphology is named « generating parametrizator morphology » ; its objects are named « parametrizator-index » and its morphisms are named « parametrizator-arrow » . This generating morphology will generate the « parametrizator-objects » ( or simply , « parameter » ) and « parametrizator-morphisms » inside the « parametrizator morphology » . Secondly , the "total space" generating morphology is named « generator morphology » and generates the « forms morphology » , and will be presented in the next section .

  Moreover in contrast , the sense-decodings ( "Yoneda" ) of the things/codes in both these generated grammar will be (meta-)functors [Yoneda01_functor] or natural transformations [Yoneda10_natural] over the « generator morphology » not the « generating parametrizator morphology » .

#+BEGIN_SRC coq :exports both :results silent # # **)
Require Import ssreflect ssrfun ssrbool.
Require Lia.

Module PARAMETRIZATION.

Set Implicit Arguments. Unset Strict Implicit. Unset Printing Implicit Defensive.
Set Primitive Projections.

Declare Scope poly_scope. Delimit Scope poly_scope with poly. Open Scope poly.

Parameter obParametrizator : Type.
Parameter morParametrizator : obParametrizator -> obParametrizator -> Type.
Parameter polyParametrizator :
  forall A A', morParametrizator A' A -> forall A'', morParametrizator A'' A' -> morParametrizator A'' A .
Parameter unitParametrizator : forall {A : obParametrizator}, morParametrizator A A.
Notation "''Parametrizator' (  A'  ~>  A  )" := (@morParametrizator A' A) (at level 0) : poly_scope.
Notation "_@ A''  o>Parametrizator  a'" := (@polyParametrizator _ _ a' A'')
          (at level 40, A'' , a' at next level, left associativity) : poly_scope.
Notation "a_ o>Parametrizator a'" := (@polyParametrizator _ _ a' _ a_)
                                  (at level 40, a' at next level) : poly_scope.
Axiom polyParametrizator_morphism :
  forall (A A' : obParametrizator) (a' : 'Parametrizator( A' ~> A ))
    (A'' : obParametrizator) (a_ : 'Parametrizator( A'' ~> A' )),
  forall B (b : 'Parametrizator( B ~> A'' )),
      b o>Parametrizator ( a_ o>Parametrizator a' ) = ( b o>Parametrizator a_ ) o>Parametrizator a' .
Axiom polyParametrizator_unitParametrizator :
  forall (A A' : obParametrizator) (a' : 'Parametrizator( A' ~> A )),
    a' = ( (@unitParametrizator A') o>Parametrizator a' ) .
Axiom unitParametrizator_polyParametrizator :
  forall (A : obParametrizator), forall (A'' : obParametrizator) (a_ : 'Parametrizator( A'' ~> A )),
    a_ = ( a_ o>Parametrizator (@unitParametrizator A) ) .
(** # #
#+END_SRC

** Generating parametrized-forms

  Moreover , the "total space" generating morphology is named « generator morphology » ; its objects are named « generator-index » and its morphisms are named « generator-arrow » . This generating-morphology will generate « parametrized-objects » and « parametrized-morphisms » , which together are named « parametrized-forms » , inside the « forms morphology » .

  Finally , some "fibration" « generating parametrization functor » from the « generator morphology » to the « generating parametrizator morphology » is presented . This generating parametrization functor is not assumed to be « full functor » . But as shall be discovered later , some assumption of generating parametrization-functor which is « full functor » would be simpler because then any element of some parametrizator-object (element of metafunctor over the generator-morphology not the generating-parametrizator-morphology) has some fixed-chosen extension as polyelement (metatransformation) .

#+BEGIN_SRC coq :exports both :results silent # # **)
Parameter obGenerator : Type.
Parameter morGenerator : obGenerator -> obGenerator -> Type.
Parameter polyGenerator :
  forall A A', morGenerator A' A -> forall A'', morGenerator A'' A' -> morGenerator A'' A .
Parameter unitGenerator : forall {A : obGenerator}, morGenerator A A.
Notation "''Generator' ( A' ~> A )" := (@morGenerator A' A)
                  (at level 0, format "''Generator' (  A'  ~>  A  )") : poly_scope.
Notation "_@ A''  o>Generator  a'" := (@polyGenerator _ _ a' A'')
          (at level 40, A'' , a' at next level, left associativity) : poly_scope.
Notation "a_ o>Generator a'" := (@polyGenerator _ _ a' _ a_)
                                  (at level 40, a' at next level) : poly_scope.
Axiom polyGenerator_morphism :
  forall (A A' : obGenerator) (a' : 'Generator( A' ~> A ))
    (A'' : obGenerator) (a_ : 'Generator( A'' ~> A' )),
  forall B (b : 'Generator( B ~> A'' )),
      b o>Generator ( a_ o>Generator a' ) = ( b o>Generator a_ ) o>Generator a' .
Axiom polyGenerator_unitGenerator :
  forall (A A' : obGenerator) (a' : 'Generator( A' ~> A )),
    a' = ( (@unitGenerator A') o>Generator a' ) .
Axiom unitGenerator_polyGenerator :
  forall (A : obGenerator), forall (A'' : obGenerator) (a_ : 'Generator( A'' ~> A )),
    a_ = ( a_ o>Generator (@unitGenerator A) ) .

Parameter Parameter0 : obGenerator -> obParametrizator.
Parameter Parameter1 : forall A A' : obGenerator,
    'Generator( A ~> A' ) -> 'Parametrizator( Parameter0 A ~> Parameter0 A') .
Axiom Parameter_morphism :
  forall (A A' : obGenerator) (a' : 'Generator( A' ~> A ))
    (A'' : obGenerator) (a_ : 'Generator( A'' ~> A' )),
    Parameter1 ( a_ o>Generator a' ) = ( Parameter1 a_ ) o>Parametrizator (Parameter1 a').
Axiom Parameter_unitGenerator :
  forall (A : obGenerator),
    (@unitParametrizator (Parameter0 A)) = ( Parameter1 (@unitGenerator A) ) .

(**TODO: make use of this NOOP head constant [Element_data] everywhere ;
  in particular , would be useful to match hypotheses such as
  [ param : Element_data Yoneda00_Param_F G ] in tactics such as [tac_param_all] **)
Definition Element_data (Yoneda00 : obGenerator -> Type) (G : obGenerator) : Type
  := (Yoneda00 G).

Definition Yoneda01_action (Yoneda00 : obGenerator -> Type)
           (Yoneda01 : forall G G' : obGenerator,
               'Generator( G' ~> G ) -> Yoneda00 G -> Yoneda00 G')
           G G' (g : 'Generator( G' ~> G)) (x : Yoneda00 G)
  := (Yoneda01 G G' g x).

Notation "g o>Generator_ [ Yoneda01 ] x" := (@Yoneda01_action _ Yoneda01 _ _ g x)
                         (at level 40, x at next level) : poly_scope.
Notation "g o>Generator_ x" := (@Yoneda01_action _ _ _ _ g x)
                                 (at level 40, x at next level) : poly_scope.

Definition Yoneda01_functor (Yoneda00 : obGenerator -> Type)
           (Yoneda01 : forall G G' : obGenerator,
               'Generator( G' ~> G ) -> Yoneda00 G -> Yoneda00 G') : Prop :=
  ( forall G G' (g : 'Generator( G' ~> G)) G'' (g' : 'Generator( G'' ~> G')) x,
        g' o>Generator_[Yoneda01] (g o>Generator_[Yoneda01] x)
        = (g' o>Generator g) o>Generator_[Yoneda01] x ) /\
  ( forall G x, x = (@unitGenerator G) o>Generator_[Yoneda01] x ) .

Definition Yoneda01_data (Yoneda00 : obGenerator -> Type)
  := { Yoneda01 : ( forall G G' : obGenerator, 'Generator( G' ~> G ) -> Yoneda00 G -> Yoneda00 G' ) |
                              Yoneda01_functor Yoneda01 }.

Definition Yoneda10_natural
           Yoneda00_F (Yoneda01_F : Yoneda01_data Yoneda00_F)
           Yoneda00_E (Yoneda01_E : Yoneda01_data Yoneda00_E)
           (Yoneda10 : forall G : obGenerator, Yoneda00_F G -> Yoneda00_E G) : Prop :=
  forall G G' (g : 'Generator( G' ~> G )) (f : Yoneda00_F G),
    g o>Generator_[sval Yoneda01_E] (Yoneda10 G f)
    = Yoneda10 G' (g o>Generator_[sval Yoneda01_F] f) .

Definition Yoneda10_data
           Yoneda00_F (Yoneda01_F : Yoneda01_data Yoneda00_F)
           Yoneda00_E (Yoneda01_E : Yoneda01_data Yoneda00_E)
  :=  { Yoneda10 : ( forall G : obGenerator, Yoneda00_F G -> Yoneda00_E G ) |
      Yoneda10_natural Yoneda01_F Yoneda01_E Yoneda10 } .
(** # #
#+END_SRC

* Grammatical presentation of objects

  As common , the sense-decoding of any form-object is some metafunctor over the « generator » morphology ( [obGenerator] ) ; the sense-decoding of any form-morphism is some metatransformation over the « generator » morphology . In contrast , the sense-decoding of any parametrizator-object is some metafunctor over the « generator » morphology ( not the parametrizator-morphology /!\ ) ; the sense-decoding of any parametrizator-morphism is some metatransformation over the « generator » morphology  ( not the parametrizator morphology /!\ ) .

  And the grammatical objects are simultaneously-mutually presented with their sense-decoding ; this could be done via some common inductive-recursive presentation or alternatively by inferring the sense-decoding computation into extra indexes of the type-family of the objects . This same comment holds for the presentation of grammatical morphisms .

  Memo that these sense-decodings may be held for two ends : (1) to express the logical-properties which are carried-as-arguments by the many morphisms constructors ; (2) to express the dependence of the output limit-object ( pi-substitution-object ) on the parametrizator-morphisms contained in some given input diagram ( here the object [Subst] ) .

  Moreover, the form-objects and the parametrizator-objects are presented mutually-inductively . Both the form-morphology and the parametrizator-morphology have their own viewing-data and (modified-)colimiting(-structure) ( [ViewingFunctor_default] , [ViewedFunctor_default] , [ViewedFunctor1_default] , [UnitViewedFunctor_default] , [PolyElement_default] , [PolyTransf_default] , and similarly [ViewingFunctor_Param_default] ... ) , which are interdependent . For now , oneself assumes that this viewing-data is the default-viewing data , and therefore only the critical skeleton of the grammar is shown ...

  Moreover , the form-morphology has the substitution-object ( [Subst] ) , which depends on some fixed-given substitution morphism via its "Yoneda" sense-decoding .

  And the parametrizator-morphology has the « formatting » constructor ( [Format] , [Formatting] ) , which does « formatting » ( "context extension" by any form-morphism , beyond the common "context extension" by own lifting ) from some form-morphism downto some parametrizator-arrow . This [Format] parametrizator-index (parameter) really is the common "pullback" ; this will become clearer later in the case of « pi-substitution » objects ...

  Again , memo that the form-objects and the parametrizator-objects are presented mutually-inductively . This mutual-induction is not nested-mutual-induction because of the presence of the [Format] constructor ; also later oneself shall discover that the grammatical-reduction (oriented conversion) of form-morphisms would not infer the reduction of their carried parametrizator-morphisms codes , but only does infer the same sense-decodings ( which is solution conversion , which is priorly decidable in the case of discrete fibrations ) . Therefore , for non-discrete fibrations , the « sharing » between the inductive-type-families of the form-morphology and the parametrizator-morphology is (should and must) via the "Yoneda" sense-decodings not-via grammatical-codes ; in contrast to the earlier [cartierSolution6.v] for non-contextual ( "1-weighted" ) 2-fold ( "2-higher" ) pairing-projections ( "product" ) , where the "1-level" codes are nested/carried by the "2-level" codes ... Regardless , in some alternative refined presentation , the inductive-type-family for the form-morphisms shall be able to carry the parametrizator-objects codes .

  Memo that clearly it can be shown that all the operations can be extended (well-defined) along the quotienting axioms ( for now only [Yoneda00_Form_Subst_quotientLogical] ) .

** Sense-decodings of the objects

#+BEGIN_SRC coq :exports both :results silent # # **)
Module Export Senses_obCoMod.
Notation "''exists'  x  ..." := (exist _ x _) (at level 10, x at next level) : poly_scope.
Notation "[<  data  |  ...  >]" := (exist (fun data : _ => sval _ _ data = _ ) data _) (at level 0) : poly_scope.

Lemma Yoneda00_View : forall (G : obGenerator), (obGenerator -> Type).
Proof. intros G. refine (fun H => 'Generator( H ~> G ) ). Defined.

Lemma Yoneda01_View : forall (G : obGenerator),
    {Yoneda01 : ( forall H H' : obGenerator,
          'Generator( H' ~> H ) -> (Yoneda00_View G) H -> (Yoneda00_View G) H' ) |
     Yoneda01_functor Yoneda01} .
Proof.
  intros. unshelve eexists.
  - intros H H' h. refine (fun g => h o>Generator g).
  - abstract (split; [intros; exact: polyGenerator_morphism
                   | intros; exact: polyGenerator_unitGenerator]).
Defined.

Lemma Yoneda00_Param_View : forall (P : obParametrizator), (obGenerator -> Type).
Proof. intros P. refine (fun Q => 'Parametrizator( Parameter0 Q ~> P ) ). Defined.

Lemma Yoneda01_Param_View : forall (P : obParametrizator),
    {Yoneda01 : ( forall Q Q' : obGenerator,
          'Generator( Q' ~> Q ) -> (Yoneda00_Param_View P) Q -> (Yoneda00_Param_View P) Q' ) |
     Yoneda01_functor Yoneda01} .
Proof.
  intros. unshelve eexists.
  - intros Q Q' q. refine (fun p => (Parameter1 q) o>Parametrizator p).
  - abstract (split; [ intros; rewrite /Yoneda01_action /= ; rewrite polyParametrizator_morphism Parameter_morphism; reflexivity
                     | intros; rewrite /Yoneda01_action /= ; rewrite -Parameter_unitGenerator; exact: polyParametrizator_unitParametrizator ]) .
Defined.

Lemma Yoneda10_FormParam_View :  forall G : obGenerator ,
    { Yoneda10 : ( forall H : obGenerator, Yoneda00_View G H -> Yoneda00_Param_View (Parameter0 G) H ) |
      Yoneda10_natural (Yoneda01_View G) (Yoneda01_Param_View (Parameter0 G)) Yoneda10 } .
Proof.
  intros G. unshelve eexists.
  - intros H. refine (@Parameter1 H G).
  - abstract(move; intros; symmetry; exact: Parameter_morphism).
Defined.

Section Yoneda00_AtParam_.
Variables (Yoneda00_Form_F : obGenerator -> Type)
          (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F)
          (Yoneda00_Param_F : obGenerator -> Type)
          (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
          (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F).

Definition Yoneda00_AtParam_
 (G : obGenerator) (param : Yoneda00_Param_F G)
  := {form : Yoneda00_Form_F G | sval Yoneda10_FormParam_F G form = param} .

Definition Yoneda01_AtParam_action
  (Yoneda01_AtParam : ( forall G (param : Yoneda00_Param_F G) (G' : obGenerator) (g : 'Generator( G' ~> G )),
                          Yoneda00_AtParam_ param -> Yoneda00_AtParam_ (g o>Generator_[sval Yoneda01_Param_F] param) ))
  G (param : Yoneda00_Param_F G) (G' : obGenerator) (g : 'Generator( G' ~> G )) (form : Yoneda00_AtParam_ param)
  := (Yoneda01_AtParam G param G' g form).
End Yoneda00_AtParam_.

Notation "''Generator' (  G'  ~>  G  @_  param  )" :=
  (@Yoneda00_AtParam_ _ _ _ _ (Yoneda10_FormParam_View G) G' param) (at level 0) : poly_scope.

Definition polyGenerator_AtParam : forall G (G' : obGenerator) (g' : 'Generator( G' ~> G )), forall (G'' : obGenerator) param' , 'Generator( G'' ~> G' @_ param' ) -> 'Generator( G'' ~> G  @_ (param' o>Parametrizator (Parameter1 g')) ) .
Proof.
  intros G G' g' G'' param' g_; unshelve eexists.  refine (sval g_ o>Generator g').
  - abstract (simpl; rewrite Parameter_morphism;
      rewrite [Parameter1 (sval g_)](proj2_sig g_); reflexivity).
Defined.

Definition unitGenerator_AtParam : forall {G : obGenerator} , 'Generator( G ~> G @_ unitParametrizator ) .
Proof.
  intros. exists (@unitGenerator G).
  abstract (simpl; symmetry; exact: Parameter_unitGenerator).
Defined.

Notation "gp_ o>GeneratorAtParam g'" :=
  (@polyGenerator_AtParam _ _ g' _ _ gp_) (at level 40, g' at next level) : poly_scope.
Notation "g o>GeneratorAtParam_ [ Yoneda01_AtParam ] form" :=
  (@Yoneda01_AtParam_action _ _ _ _ _ Yoneda01_AtParam  _ _ _ g form)
    (at level 40, form at next level) : poly_scope.
Notation "g o>GeneratorAtParam_ form" :=
  (@Yoneda01_AtParam_action _ _ _ _ _ _  _ _ _ g form)
    (at level 40, form at next level) : poly_scope.

Section Yoneda01_AtParam_.
Variables (Yoneda00_Form_F : obGenerator -> Type)
 (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F)
 (Yoneda00_Param_F : obGenerator -> Type)
 (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
 (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F).

Definition Yoneda01_AtParam_functor
  (Yoneda01_AtParam : ( forall G (param : Yoneda00_Param_F G) (G' : obGenerator) (g : 'Generator( G' ~> G )),
                          Yoneda00_AtParam_ Yoneda10_FormParam_F param -> Yoneda00_AtParam_ Yoneda10_FormParam_F (g o>Generator_[sval Yoneda01_Param_F] param) )): Prop :=
  ( forall G param G' (g : 'Generator( G' ~> G)) G'' (g' : 'Generator( G'' ~> G')) (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
      sval (g' o>GeneratorAtParam_[Yoneda01_AtParam] (g o>GeneratorAtParam_[Yoneda01_AtParam] form)) =
      sval ((g' o>Generator g) o>GeneratorAtParam_[Yoneda01_AtParam] form )) /\
  ( forall G param (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
      sval form = sval ((@unitGenerator G) o>GeneratorAtParam_[Yoneda01_AtParam] form) ) .

Definition Yoneda01_AtParam_data
  := { Yoneda01_AtParam : ( forall G (param : Yoneda00_Param_F G) (G' : obGenerator) (g : 'Generator( G' ~> G )),
                              Yoneda00_AtParam_ Yoneda10_FormParam_F param -> Yoneda00_AtParam_ Yoneda10_FormParam_F (g o>Generator_[sval Yoneda01_Param_F] param) ) |
       Yoneda01_AtParam_functor Yoneda01_AtParam }.

Definition Yoneda01_AtParam_ : Yoneda01_AtParam_data.
Proof.
  unshelve eexists.
  - intros G param G' g form. exists (g o>Generator_[sval Yoneda01_Form_F] (sval form)).
    abstract(rewrite -[LHS](proj2_sig Yoneda10_FormParam_F); rewrite [in LHS](proj2_sig form); reflexivity).
  - abstract(split; move; simpl; intros; [ exact: (proj1 (proj2_sig Yoneda01_Form_F))
                                         | exact: (proj2 (proj2_sig Yoneda01_Form_F)) ]).
Defined.
End Yoneda01_AtParam_.

Section Subst.
Variables (Yoneda00_Form_F : obGenerator -> Type)
          (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F)
          (Yoneda00_Param_F : obGenerator -> Type)
          (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
          (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F)
          (Yoneda00_Param_F' : obGenerator -> Type)
          (Yoneda01_Param_F' : Yoneda01_data Yoneda00_Param_F')
          (Yoneda10_Param_subst : Yoneda10_data Yoneda01_Param_F' Yoneda01_Param_F).

Definition Yoneda00_Form_Subst : obGenerator -> Type.
Proof.
  refine (fun H : obGenerator => { xf : (Yoneda00_Param_F' H * Yoneda00_Form_F H)%type |
                                sval Yoneda10_Param_subst _ ( fst xf ) = sval Yoneda10_FormParam_F _ ( snd xf ) } ).
Defined.

Axiom Yoneda00_Form_Subst_quotientLogical :
  forall G (form form' : Yoneda00_Form_Subst G), snd (sval form) = snd (sval form') -> form = form'.

Definition Yoneda01_Form_Subst : Yoneda01_data Yoneda00_Form_Subst.
Proof.
  unshelve eexists.
  - intros H H' h xf.
    exists ( h o>Generator_[sval Yoneda01_Param_F'] (fst (sval xf)) , h o>Generator_[sval Yoneda01_Form_F] (snd (sval xf)) ) .
    abstract (simpl; rewrite -[LHS](proj2_sig Yoneda10_Param_subst); rewrite -[RHS](proj2_sig Yoneda10_FormParam_F);
              congr (h o>Generator_ _); exact: (proj2_sig xf)).
  - abstract (split; simpl;
              first (by intros; apply: Yoneda00_Form_Subst_quotientLogical; simpl;
                     rewrite -[in RHS](proj1 (proj2_sig (Yoneda01_Form_F))); reflexivity);
              intros H xf; apply: Yoneda00_Form_Subst_quotientLogical; simpl;
              rewrite -[in RHS](proj2 (proj2_sig (Yoneda01_Form_F)));
              move: (sval xf) => sval_xf; destruct sval_xf; reflexivity).
Defined.

Definition Yoneda10_FormParam_Subst : Yoneda10_data Yoneda01_Form_Subst Yoneda01_Param_F'.
Proof.
  unshelve eexists.
  - intros G xf. exact: (fst (sval xf)).
  - abstract (move; reflexivity).
Defined.
End Subst.

Definition Yoneda10_Id : forall (Yoneda00_F : obGenerator -> Type) (Yoneda01_F : Yoneda01_data Yoneda00_F),
    Yoneda10_data Yoneda01_F Yoneda01_F.
Proof.
  intros; unshelve eexists.
  - intros G. refine (id).
  - abstract(move; reflexivity).
Defined.
End Senses_obCoMod.
(** # #
#+END_SRC

** Finiteness of the viewing-elements of some viewing-functor

  The grammatical colimiting/sum/sigma/viewing-functor-objects [ViewingFunctor_default] assume some finiteness properties ( such as finite-compactness or finite-dimensionality or finite-generated ) onto the viewing-data/topology sense-decodings which they internalize . And these viewing-functor-objects are similar as generators ( representable-functors ) but to be used for functors which are already viewed-functors ( "sheaf" ) . Therefore , and knowning that the viewed-functor construction is exact and commutes with limits ,  oneself may add/express such things as « viewed-substitution » or « viewed-pi-substitution » , as long as the codomain is already some viewed-functor and the domain for the « cartesian » property is now some viewing-functor .

  To facilitate the COQ automatic-arithmetic during the degradation lemma , here oneself shall assume that the cardinality is fixed-the-same for each of the viewing-functor .

#+BEGIN_SRC coq :exports both :results silent # # **)
Module Finiteness.
Parameter isFiniteness_Param_ : forall Yoneda00_Param_F (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F), Prop.

Parameter (G1 : forall Yoneda00_Param_F (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
                  (isFiniteness_Param_F : isFiniteness_Param_ Yoneda01_Param_F), obGenerator).
Parameter (param1 : forall Yoneda00_Param_F (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
                      (isFiniteness_Param_F : isFiniteness_Param_ Yoneda01_Param_F),
              Yoneda00_Param_F (G1 isFiniteness_Param_F)).
Parameter (G2 : forall Yoneda00_Param_F (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
                  (isFiniteness_Param_F : isFiniteness_Param_ Yoneda01_Param_F), obGenerator).
Parameter (param2 : forall Yoneda00_Param_F (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
                      (isFiniteness_Param_F : isFiniteness_Param_ Yoneda01_Param_F),
              Yoneda00_Param_F (G2 isFiniteness_Param_F)).

Section Section1.
  Variables (Yoneda00_Param_F : obGenerator -> Type) (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
            (isFiniteness_Param_F : isFiniteness_Param_ Yoneda01_Param_F).

Inductive is_viewingFunctorParamElement12 : forall (G : obGenerator) (param : Yoneda00_Param_F G), Type :=
| Is_viewingFunctorParamElement12_viewingFunctorParamElement1 : is_viewingFunctorParamElement12 (param1 isFiniteness_Param_F)
| Is_viewingFunctorParamElement12_viewingFunctorParamElement2 : is_viewingFunctorParamElement12 (param2 isFiniteness_Param_F) .

Axiom is_viewingFunctorParamElement12_allP : forall (G : obGenerator) (param : Yoneda00_Param_F G), is_viewingFunctorParamElement12 param.
End Section1.

Parameter isFiniteness_FormParam_ : forall Yoneda00_Form_F (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F),
    forall Yoneda00_Param_F (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F),
    forall Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F, Prop.

Parameter (form1 form2 : forall Yoneda00_Form_F (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F),
              forall Yoneda00_Param_F (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F),
              forall Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F,
              forall (isFiniteness_FormParam_F : isFiniteness_FormParam_ Yoneda10_FormParam_F),
              forall G :  obGenerator, forall param : Yoneda00_Param_F G, Yoneda00_AtParam_ Yoneda10_FormParam_F param).

Section Section2.
Variables (Yoneda00_Form_F : obGenerator -> Type)
          (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F)
          (Yoneda00_Param_F : obGenerator -> Type)
          (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
          (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F)
          (isFiniteness_FormParam_F : isFiniteness_FormParam_ Yoneda10_FormParam_F)
          (G : obGenerator) (param : Yoneda00_Param_F G).

Inductive is_viewingFunctorElement12 : forall (form: Yoneda00_AtParam_ Yoneda10_FormParam_F param), Type :=
| Is_viewingFunctorElement12_viewingFunctorElement1 : is_viewingFunctorElement12 (form1 isFiniteness_FormParam_F param)
| Is_viewingFunctorElement12_viewingFunctorElement2 : is_viewingFunctorElement12 (form2 isFiniteness_FormParam_F param) .

Axiom is_viewingFunctorElement12_allP : forall (form: Yoneda00_AtParam_ Yoneda10_FormParam_F param), is_viewingFunctorElement12 form.
End Section2.
End Finiteness.
(** # #
#+END_SRC

** Grammar of the objects, which carry the sense-decodings

  As common , the [View] form-object/index constructor is the (covariant) Yoneda-embedding ( therefore [View G] is some contravariant metafunctor ) . Similarly for the [View_Param] parametrizator-object/index constructor .

  Memo that the sum/colimit/sigma-object [ViewingFunctor_default] is simply the grammar/internalization of any (sense/external) viewing-functor which has some finiteness properties ( such as finite-compactness or finite-dimensionality or finite-generated ) , and therefore the sense-decodings of this grammatical sum/colimit/sigma-object is the same as this sense/external viewing-functor . But grammatically , only the viewing-elements of the viewing-functor are touchable (via the morphism constructor [PolyElement_default]) .

  Moreover , the form-morphology has the substitution-object ( [Subst] ) , which depends on one fixed-given substitution morphism via its "Yoneda" sense-decoding [Yoneda10_Param_subst] .

  And the [Format] parametrizator-index (parameter) really is the common "pullback" ; this will become clearer later in the case of « pi-substitution » objects ...

#+BEGIN_SRC coq :exports both :results silent # # **)
Inductive obCoMod : forall Yoneda00_Form_F (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F),
    forall Yoneda00_Param_F (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F),
    forall Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F, Type :=

| View : forall G : obGenerator, @obCoMod (Yoneda00_View G) (Yoneda01_View G)
  (Yoneda00_Param_View (Parameter0 G)) (Yoneda01_Param_View (Parameter0 G)) (Yoneda10_FormParam_View G)

| ViewingFunctor_default : forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F,
    forall (isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F)
      (isFiniteness_FormParam_F : Finiteness.isFiniteness_FormParam_ Yoneda10_FormParam_F),
      @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F

| ViewedFunctor_default : forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
                            (F: @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F)
                            (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
                     @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F

| Subst : forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
            (F: @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F)
            (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall (Yoneda00_Param_SubstF : obGenerator -> Type)
      (Yoneda01_Param_SubstF : Yoneda01_data Yoneda00_Param_SubstF)
      (Param_SubstF : @obCoMod_Param Yoneda00_Param_SubstF Yoneda01_Param_SubstF),
    forall (Yoneda10_Param_subst : Yoneda10_data Yoneda01_Param_SubstF Yoneda01_Param_F),
      @obCoMod (Yoneda00_Form_Subst Yoneda10_FormParam_F Yoneda10_Param_subst)
               (Yoneda01_Form_Subst Yoneda10_FormParam_F Yoneda10_Param_subst)
               Yoneda00_Param_SubstF Yoneda01_Param_SubstF
               (Yoneda10_FormParam_Subst Yoneda10_FormParam_F Yoneda10_Param_subst)

with obCoMod_Param : forall Yoneda00_Param_F (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F), Type :=

| View_Param : forall P : obParametrizator, @obCoMod_Param (Yoneda00_Param_View P) (Yoneda01_Param_View P)

| ViewingFunctor_Param_default : forall Yoneda00_Param_F Yoneda01_Param_F,
    forall (isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F),
    @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F

| ViewedFunctor_Param_default : forall Yoneda00_Param_F Yoneda01_Param_F
                             (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F

| Format : forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
             (F: @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F)
             (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
      @obCoMod_Param (Yoneda00_Form_Subst Yoneda10_FormParam_F (Yoneda10_Id Yoneda01_Param_F))
               (Yoneda01_Form_Subst Yoneda10_FormParam_F (Yoneda10_Id Yoneda01_Param_F)) .
(** # #
#+END_SRC

* Grammatical presentation of morphisms

** Sense-decodings of the morphisms

  The sense-decoding of any form-morphism is some metatransformation over the « generator » morphology . The sense-decoding of any parametrizator-morphism is some metatransformation over the « generator » morphology  not the generating-parametrizator-morphology . Memo that these sense-decodings may be held for two ends : (1) to express the logical-properties which are carried-as-arguments by the many morphisms constructors ; (2) to express the dependence of the output limit-object ( pi-substitution-object ) on the parametrizator-morphisms contained in some given input diagram ( here the object [Subst] ) .

  And both the form-morphology and the parametrizator-morphology have their own viewing-data and (modified-)colimiting(-structure) ( [ViewingFunctor_default] , [ViewedFunctor_default] , [ViewedFunctor1_default] , [UnitViewedFunctor_default] , [PolyElement_default] , [PolyTransf_default] , and similarly [ViewingFunctor_Param_default] ... ) . Memo that the sum/colimit/sigma-object [ViewingFunctor_default] is simply the grammar/internalization of any (sense/external) viewing-functor which has some finiteness properties ( such as finite-compactness or finite-dimensionality or finite-generated ) , and therefore the sense-decodings of this grammatical sum/colimit/sigma-object is the same as this sense/external viewing-functor . But grammatically , only the viewing-elements of the viewing-functor are touchable (via the morphism constructor [PolyElement_default]) .

  As common , the [View1] form-morphism/arrow constructor ( which is used to do grammatical « action » ) is the (covariant) Yoneda-embedding ( therefore [View G] is some contravariant metafunctor ) . In contrast , the presentation of the [View1_Param] parametrizator-morphism/arrow constructor ( which is used to do grammatical « action » ) allows some action by any parametrizator-arrow whose domain is the image ( as attested by the inductive [is_Parameter0] ) of some generator-index ; similarly for the sum/colimit/sigma-parametrizator-object [ViewingFunctor_Param_default] , the domain is the image of some generator-index

  Moreover , as explained above , because the generating parametrization-functor is not assumed to be  « full functor » , then it does not hold that any element of some parametrizator-object (element of metafunctor over the generator-morphology not the generating-parametrizator-morphology) has some fixed-chosen extension as polyelement (metatransformation) . Therefore the constructors of the modified-colimiting-structure ( [PolyElement_default] , [PolyTransf_default] , [PolyElement_Param_default] , [PolyTransf_Param_default] ) shall carry-as-argument some « parameter polyelement-extensioner » ( here [Yoneda10_Param_param_] ) .

  Memo that the summing/colimiting/copairing form-morphism constructor [PolyTransf_default] is supported-below by some cocone of parametrizator-morphisms grammatical-codes ; this is necessary during the cut-elimination resolution . Consequently , the viewed-functor constructor [ViewedFunctor1_default] is also supported-below by some parametrizator-morphism grammatical-code ;  this is necessary during the cut-elimination resolution .

  As common , the forget-morphism ( [Forget] ) for the substitution-object is « polymorph » because it carries/has as-argument some « accumulator form-morphism » ( [ee] ) . In contrast , the forget-morphism ( [Forget] ) and the remember-morphism ( [Remember] ) for the substitution-object are moreover « polyobject » because the precise parametrizator-morphism ( sense-decoding ) argument which defines the subtitution-object ( in the domain for [Forget] or in the codomain for [Remember] ), can be chosen ( [Yoneda10_Param_Forget'] ) .

  Memo that the domain of the remember-morphism ( [Remember] ) for the substitution-object is not the most-general , but is some generator-object ( [View] , "representable-functor" ) . Such generator-object is the polymorh correspondent to the ( implicit ) « singleton set » which is used in the sense . This is the intended « cartesian » property . This ( intended , as in the lambda calculus ) limitation can be erased in the case when the generating parametrization-functor is « sense-discrete » , where the parametrizator-morphisms are nested within the inductive-type-family of the form-morphisms and are therefore priorly decidable .

  Finally because for now this viewing-data is already assumed to be the default-viewing-data , it is not yet interesting to present/express/add the « common-modified-colimiting constructor » ( such as [PolyTransf_default_common] ) where the (input) target/codomain functor is already some viewed-functor .

#+BEGIN_SRC coq :exports both :results silent # # **)
Module Export Senses_morCoMod.
Lemma Yoneda10_Param_PolyCoMod :
  forall Yoneda00_F1 Yoneda01_F1 Yoneda00_F2 Yoneda01_F2
   (Yoneda10_ff_ : {Yoneda10 : forall A : obGenerator, Yoneda00_F1 A -> Yoneda00_F2 A |
                     Yoneda10_natural Yoneda01_F1 Yoneda01_F2 Yoneda10 })
    Yoneda00_F2' Yoneda01_F2'
  (Yoneda10_ff' : {Yoneda10 : forall A : obGenerator, Yoneda00_F2 A -> Yoneda00_F2' A |
                   Yoneda10_natural Yoneda01_F2 Yoneda01_F2' Yoneda10}),
    {Yoneda10 : ( forall A : obGenerator, Yoneda00_F1 A -> Yoneda00_F2' A ) |
     Yoneda10_natural Yoneda01_F1 Yoneda01_F2' Yoneda10}.
Proof.
  intros. exists (fun A => (sval Yoneda10_ff') A \o (sval Yoneda10_ff_) A ).
  abstract (intros; move; intros; simpl; rewrite (proj2_sig Yoneda10_ff')
                                            (proj2_sig Yoneda10_ff_); reflexivity).
Defined.

Lemma Yoneda10_UnitCoMod_Param :
  forall Yoneda00_Param_F (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F),
    Yoneda10_data Yoneda01_Param_F Yoneda01_Param_F .
Proof.
  intros. exists (fun G => id).
  abstract (intros; move; intros; reflexivity).
Defined.

Definition Yoneda10_Param_View1 :
  forall (P : obParametrizator)
(Q : obParametrizator)
(p : 'Parametrizator( P ~> Q )),
{Yoneda10 : forall G : obGenerator, Yoneda00_Param_View P G -> Yoneda00_Param_View Q G | Yoneda10_natural (Yoneda01_Param_View P) (Yoneda01_Param_View Q) Yoneda10}.
Proof.
  intros. unshelve eexists.
  - intros G. refine (_@ (Parameter0  G) o>Parametrizator p ).
  - abstract (move; intros; rewrite /Yoneda01_action /= ; exact: polyParametrizator_morphism).
Defined.

Section is_Parameter0.
Variables (G : obGenerator).

Inductive is_Parameter0 : forall (P : obParametrizator), Type :=
| Is_Parameter0 : is_Parameter0 (Parameter0 G) .

Definition is_Parameter0_transp_rev_codom :  forall (P : obParametrizator) (is_Parameter0_P : is_Parameter0 P),
    forall G' (p : 'Parametrizator( G' ~> Parameter0 G )), 'Parametrizator( G' ~> P ).
Proof.
  intros. destruct is_Parameter0_P. exact: p.
Defined.

Definition is_Parameter0_transp_dom :  forall (P : obParametrizator) (is_Parameter0_P : is_Parameter0 P),
    forall G' (p : 'Parametrizator( P ~> G' )), 'Parametrizator( Parameter0 G ~> G' ) .
Proof.
  intros. destruct is_Parameter0_P. exact: p.
Defined.
End is_Parameter0.

(**MEMO: also refer [Yoneda10_Param_PolyTransf_default_Param] below *)
Definition Yoneda10_Param_PolyTransf_default :
 forall (Yoneda00_Param_F : obGenerator -> Type)
(Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
(Yoneda10_Param_param_ : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F )
(Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G),
    param = sval (Yoneda10_Param_param_ G param) G (@unitParametrizator (Parameter0 G)) )
(Yoneda00_Param_E : obGenerator -> Type)
(Yoneda01_Param_E : Yoneda01_data Yoneda00_Param_E)
(Yoneda10_Param_ee0 :
forall (G : obGenerator) (param : Yoneda00_Param_F G),  Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_E)
(Yoneda10_Param_ee0_morphism :
   forall G (param : Yoneda00_Param_F G),
   forall (param_ : Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F )
     (Heq_param :  param = sval param_ G (@unitParametrizator (Parameter0 G)) ),
   forall G'  (param' : Yoneda00_Param_View (Parameter0 G) G')
     G'' (param'' : Yoneda00_Param_View (Parameter0 G') G''),
     sval (Yoneda10_Param_ee0 G param) G'' (param'' o>Parametrizator param') =
     sval (Yoneda10_Param_ee0 G' (sval param_ G' param')) G'' param''),
   Yoneda10_data Yoneda01_Param_F Yoneda01_Param_E.
Proof.
  intros; unshelve eexists.
  - intros G param. refine (sval (Yoneda10_Param_ee0 G param) G (unitParametrizator)).
  - move; simpl; intros G G' g param;  rewrite [LHS](proj2_sig (Yoneda10_Param_ee0 G param)).
    rewrite -[_ o>Generator_ _]unitParametrizator_polyParametrizator.
    rewrite [Parameter1 g]polyParametrizator_unitParametrizator.
    rewrite [LHS](@Yoneda10_Param_ee0_morphism _ _ _ (Heq_param G param)).
    rewrite [Parameter1 g]unitParametrizator_polyParametrizator.
    rewrite -[in LHS](proj2_sig (Yoneda10_Param_param_ G param));
    rewrite -[in LHS]Heq_param; reflexivity.
Defined.

(**MEMO: alt phrasing of [Yoneda10_Param_PolyTransf_default] above *)
Definition Yoneda10_Param_PolyTransf_default_Param :
  forall (Yoneda00_Param_F : obGenerator -> Type)
    (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
    (Yoneda10_Param_param_ : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                               (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
                               Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_F )
    (Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                   (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
        param = sval (Yoneda10_Param_param_ G param P is_Parameter0_P)
                     G (is_Parameter0_transp_rev_codom is_Parameter0_P (@unitParametrizator (Parameter0 G))) )
    (Yoneda00_Param_E : obGenerator -> Type)
    (Yoneda01_Param_E : Yoneda01_data Yoneda00_Param_E)
    (Yoneda10_Param_ee : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                           (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
                           Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_E)
    (Yoneda10_Param_ee_morphism :
       forall G (param : Yoneda00_Param_F G) (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
       forall (param_ : Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_F )
         (Heq_param :  param = sval param_ G (is_Parameter0_transp_rev_codom is_Parameter0_P (@unitParametrizator (Parameter0 G)))),
       forall G'  (param' : Yoneda00_Param_View P G')
         G'' (param'' : Yoneda00_Param_View (Parameter0 G') G''),
         sval (Yoneda10_Param_ee G param P is_Parameter0_P) G'' (param'' o>Parametrizator param') =
         sval (Yoneda10_Param_ee G' (sval param_ G' param') (Parameter0 G') (Is_Parameter0 G')) G'' param''),
    Yoneda10_data Yoneda01_Param_F Yoneda01_Param_E.
Proof.
  intros. pose Yoneda10_Param_param_' := ( fun G param => Yoneda10_Param_param_ G param (Parameter0 G) (Is_Parameter0 G) ).
  pose Yoneda10_Param_ee' := ( fun G param => Yoneda10_Param_ee G param (Parameter0 G) (Is_Parameter0 G) ).
  apply: (Yoneda10_Param_PolyTransf_default  (Yoneda10_Param_param_ := Yoneda10_Param_param_') _  (Yoneda10_Param_ee0 := Yoneda10_Param_ee')).
  abstract (exact: (fun G param => (Heq_param G param (Parameter0 G) (Is_Parameter0 G)))).
  abstract (exact: (fun G param => (Yoneda10_Param_ee_morphism G param (Parameter0 G) (Is_Parameter0 G)))).
Defined.

Section Yoneda10_Form_data.
Variables (Yoneda00_Form_E : obGenerator -> Type)
          (Yoneda01_Form_E : Yoneda01_data Yoneda00_Form_E)
          (Yoneda00_Param_E : obGenerator -> Type)
          (Yoneda01_Param_E : Yoneda01_data Yoneda00_Param_E)
          (Yoneda10_FormParam_E : Yoneda10_data Yoneda01_Form_E Yoneda01_Param_E).
Variables  (Yoneda00_Form_F : obGenerator -> Type)
           (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F)
           (Yoneda00_Param_F : obGenerator -> Type)
           (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
           (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F).
Variables (Yoneda10_Param_subst : Yoneda10_data Yoneda01_Param_E Yoneda01_Param_F).

  Section Section1.
  Variables (Yoneda10_Form_ff : forall (G : obGenerator) (param : Yoneda00_Param_E G),
                Yoneda00_AtParam_ Yoneda10_FormParam_E ( (**TODO: (sval Yoneda10_Param_project G) **) param) ->
                Yoneda00_AtParam_ Yoneda10_FormParam_F ((sval Yoneda10_Param_subst G) param)).

  Definition Yoneda10_Form_natural
    := forall (G : obGenerator) (param : Yoneda00_Param_E G) (G' : obGenerator)
         (g : 'Generator( G' ~> G )) (form : Yoneda00_AtParam_ Yoneda10_FormParam_E param),
      sval (g o>GeneratorAtParam_[sval (Yoneda01_AtParam_(Yoneda10_FormParam_F))] (@Yoneda10_Form_ff G param form))
      = sval (@Yoneda10_Form_ff G' (g o>Generator_[sval Yoneda01_Param_E] param)
                             (g o>GeneratorAtParam_[sval (Yoneda01_AtParam_(Yoneda10_FormParam_E))] form)) .

  Definition Yoneda10_Form_quotientLogical
    := forall (G : obGenerator) (param : Yoneda00_Param_E G) (form : Yoneda00_AtParam_ Yoneda10_FormParam_E param)
         (param' : Yoneda00_Param_E G) (form' : Yoneda00_AtParam_ Yoneda10_FormParam_E param'),
      sval form = sval form' ->
      sval (@Yoneda10_Form_ff G param form) = sval (@Yoneda10_Form_ff G param' form') .
  End Section1.

Definition Yoneda10_Form_data :=
  { Yoneda10_Form : forall (G : obGenerator) (param : Yoneda00_Param_E G),
      Yoneda00_AtParam_ Yoneda10_FormParam_E ( (**TODO: (sval Yoneda10_Param_project G) **) param) ->
      Yoneda00_AtParam_ Yoneda10_FormParam_F ((sval Yoneda10_Param_subst G) param) |
    Yoneda10_Form_natural Yoneda10_Form /\
    Yoneda10_Form_quotientLogical Yoneda10_Form } .

End Yoneda10_Form_data.

Definition Yoneda10_Form_PolyCoMod :
forall (Yoneda00_Form_F : obGenerator -> Type)
(Yoneda01_Form_F :
{Yoneda01
: forall G G' : obGenerator,
  'Generator( G' ~> G ) -> Yoneda00_Form_F G -> Yoneda00_Form_F G' |
Yoneda01_functor Yoneda01})
(Yoneda00_Param_F : obGenerator -> Type)
(Yoneda01_Param_F :
{Yoneda01
: forall G G' : obGenerator,
  'Generator( G' ~> G ) -> Yoneda00_Param_F G -> Yoneda00_Param_F G' |
Yoneda01_functor Yoneda01})
(Yoneda10_FormParam_F :
{Yoneda10_FormParam
: forall G : obGenerator, Yoneda00_Form_F G -> Yoneda00_Param_F G |
Yoneda10_natural Yoneda01_Form_F Yoneda01_Param_F Yoneda10_FormParam})
(Yoneda00_Form_F' : obGenerator -> Type)
(Yoneda01_Form_F' :
{Yoneda01
: forall G G' : obGenerator,
  'Generator( G' ~> G ) -> Yoneda00_Form_F' G -> Yoneda00_Form_F' G' |
Yoneda01_functor Yoneda01})
(Yoneda00_Param_F' : obGenerator -> Type)
(Yoneda01_Param_F' :
{Yoneda01
: forall G G' : obGenerator,
  'Generator( G' ~> G ) -> Yoneda00_Param_F' G -> Yoneda00_Param_F' G' |
Yoneda01_functor Yoneda01})
(Yoneda10_FormParam_F' :
{Yoneda10_FormParam
: forall G : obGenerator, Yoneda00_Form_F' G -> Yoneda00_Param_F' G |
Yoneda10_natural Yoneda01_Form_F' Yoneda01_Param_F' Yoneda10_FormParam})
(Yoneda10_Param_ff' :
{Yoneda10_Param
: forall G : obGenerator, Yoneda00_Param_F' G -> Yoneda00_Param_F G |
Yoneda10_natural Yoneda01_Param_F' Yoneda01_Param_F Yoneda10_Param})
(Yoneda10_Form_ff' :
Yoneda10_Form_data Yoneda10_FormParam_F' Yoneda10_FormParam_F
  Yoneda10_Param_ff')
(Yoneda00_Form_F'' : obGenerator -> Type)
(Yoneda01_Form_F'' :
{Yoneda01
: forall G G' : obGenerator,
  'Generator( G' ~> G ) -> Yoneda00_Form_F'' G -> Yoneda00_Form_F'' G' |
Yoneda01_functor Yoneda01})
(Yoneda00_Param_F'' : obGenerator -> Type)
(Yoneda01_Param_F'' :
{Yoneda01
: forall G G' : obGenerator,
  'Generator( G' ~> G ) -> Yoneda00_Param_F'' G -> Yoneda00_Param_F'' G' |
Yoneda01_functor Yoneda01})
(Yoneda10_FormParam_F'' :
{Yoneda10_FormParam
: forall G : obGenerator, Yoneda00_Form_F'' G -> Yoneda00_Param_F'' G |
Yoneda10_natural Yoneda01_Form_F'' Yoneda01_Param_F'' Yoneda10_FormParam})
(Yoneda10_Param_ff_ :
{Yoneda10_Param
: forall G : obGenerator, Yoneda00_Param_F'' G -> Yoneda00_Param_F' G |
Yoneda10_natural Yoneda01_Param_F'' Yoneda01_Param_F' Yoneda10_Param})
(Yoneda10_Form_ff_ :
Yoneda10_Form_data Yoneda10_FormParam_F'' Yoneda10_FormParam_F'
  Yoneda10_Param_ff_) ,
Yoneda10_Form_data Yoneda10_FormParam_F'' Yoneda10_FormParam_F
    (Yoneda10_Param_PolyCoMod Yoneda10_Param_ff_
       Yoneda10_Param_ff').
Proof.
  intros. unshelve eexists.
  - intros G param dataIn. unshelve eexists.
    + apply: (sval (sval Yoneda10_Form_ff' _ (sval Yoneda10_Param_ff_ _ param) _)). unshelve eexists.
      * exact: (sval (sval Yoneda10_Form_ff_ _ param dataIn)).
      * abstract (exact: (proj2_sig (sval Yoneda10_Form_ff_ _ _ _ ))).
    + abstract (simpl; rewrite [LHS](proj2_sig (sval Yoneda10_Form_ff' _ _ _)); reflexivity).
  - abstract (split; [ move; simpl; intros; rewrite [LHS](proj1 (proj2_sig Yoneda10_Form_ff'));
                       apply: (proj2 (proj2_sig Yoneda10_Form_ff'));
                       simpl; exact: (proj1 (proj2_sig Yoneda10_Form_ff_))
                     (*ALT:  rewrite [LHS](proj1 (proj2_sig Yoneda10_Form_ff_)).
                       apply: (proj2 (proj2_sig Yoneda10_Form_ff_)). *)
                     | move; simpl; intros; apply: (proj2 (proj2_sig Yoneda10_Form_ff'));
                       simpl; apply: (proj2 (proj2_sig Yoneda10_Form_ff_)); assumption ]).
Defined.

Definition Yoneda10_UnitCoMod
           (Yoneda00_Form_F : obGenerator -> Type)
           (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F)
           (Yoneda00_Param_F : obGenerator -> Type)
           (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
           (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F) :
    Yoneda10_Form_data Yoneda10_FormParam_F Yoneda10_FormParam_F (Yoneda10_UnitCoMod_Param Yoneda01_Param_F).
Proof.
  intros; unshelve eexists.
  - refine (fun G param => id).
  - abstract (split; move; simpl; intros; [ reflexivity | assumption ]).
Defined.

Definition Yoneda10_Form_View1 :
  forall (G : obGenerator) (H : obGenerator) (g : 'Generator( H ~> G )),
    Yoneda10_Form_data (Yoneda10_FormParam_View H) (Yoneda10_FormParam_View G)
                  (Yoneda10_Param_View1 (Parameter1 g)) .
Proof.
  intros G H hg. unshelve eexists.
  - intros G0 x h . exists ( (sval h) o>Generator hg ).
    abstract (move: (proj2_sig h); rewrite /Yoneda10_Param_View1 /Yoneda10_FormParam_View  /= ;
              rewrite Parameter_morphism ; move -> ; reflexivity).
  - abstract (split; [ move; simpl; intros ; rewrite /Yoneda01_action /= ; exact: polyGenerator_morphism
                     | move; simpl; intros; congr ( _ o>Generator hg ); assumption] ).
Defined.

Definition Yoneda10_Form_PolyElement_default :
forall (Yoneda00_Form_F : obGenerator -> Type)
(Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F)
(Yoneda00_Param_F : obGenerator -> Type)
(Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
(Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F)
(Yoneda10_Param_form_ : forall G : obGenerator, Yoneda00_Param_F G -> Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F)
(Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G), param = sval (Yoneda10_Param_form_ G param) G unitParametrizator)
(G : obGenerator)
(param : Yoneda00_Param_F G)
(form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
Yoneda10_Form_data (Yoneda10_FormParam_View G) Yoneda10_FormParam_F (Yoneda10_Param_form_ G param).
Proof.
  intros. unshelve eexists.
  - intros G0 param0 form0. exists (sval ( (sval form0) o>GeneratorAtParam_[sval (Yoneda01_AtParam_ Yoneda10_FormParam_F)] form )).
    abstract (rewrite -[LHS](proj2_sig Yoneda10_FormParam_F);
              rewrite [in LHS](proj2_sig form);
              rewrite [param in LHS]Heq_param;
              rewrite [LHS](proj2_sig (Yoneda10_Param_form_ _ _));
              congr ( sval (Yoneda10_Param_form_ _ _) );
              rewrite [LHS]/Yoneda01_action [LHS]/= -[LHS]unitParametrizator_polyParametrizator;
              exact: (proj2_sig form0) ).
  - abstract (split; [ move; simpl; intros; rewrite -[RHS](proj1 (proj2_sig Yoneda01_Form_F)); reflexivity
                      | move; simpl; intros; congr ( _ o>Generator_ (sval form) ); assumption ]).
Defined.

Definition Yoneda10_Form_PolyTransf_default :
 forall  (Yoneda00_Form_F : obGenerator -> Type)
(Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F)
(Yoneda00_Param_F : obGenerator -> Type)
(Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
(Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F)
(Yoneda10_Param_param_ : forall G : obGenerator, Yoneda00_Param_F G -> Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F)
(Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G), param = sval (Yoneda10_Param_param_ G param) G unitParametrizator)
(Yoneda00_Form_E : obGenerator -> Type)
(Yoneda01_Form_E : Yoneda01_data Yoneda00_Form_E)
(Yoneda00_Param_E : obGenerator -> Type)
(Yoneda01_Param_E : Yoneda01_data Yoneda00_Param_E)
(Yoneda10_FormParam_E : Yoneda10_data Yoneda01_Form_E Yoneda01_Param_E)
(Yoneda10_Param_ee0 : forall G : obGenerator, Yoneda00_Param_F G -> Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_E)
(Yoneda10_Param_ee0_morphism :
   forall G (param : Yoneda00_Param_F G),
   forall (param_ : Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F )
     (Heq_param :  param = sval param_ G (@unitParametrizator (Parameter0 G)) ),
   forall G'  (param' : Yoneda00_Param_View (Parameter0 G) G')
     G'' (param'' : Yoneda00_Param_View (Parameter0 G') G''),
     sval (Yoneda10_Param_ee0 G param) G'' (param'' o>Parametrizator param') =
     sval (Yoneda10_Param_ee0 G' (sval param_ G' param')) G'' param'')
(Yoneda10_Param_ee : forall (G : obGenerator) (param : Yoneda00_Param_F G), Yoneda00_AtParam_ Yoneda10_FormParam_F param -> Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_E)
(Yoneda10_Form_ee :
forall (G : obGenerator) (param : Yoneda00_Param_F G) (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
Yoneda10_Form_data (Yoneda10_FormParam_View G) Yoneda10_FormParam_E (Yoneda10_Param_ee G param form))
(Heq_param_ee :
forall (G : obGenerator) (param : Yoneda00_Param_F G) (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param) (G' : obGenerator) (param' : Yoneda00_Param_View (Parameter0 G) G'),
sval (Yoneda10_Param_ee G param form) G' param' = sval (Yoneda10_Param_ee0 G param) G' param')
(Yoneda10_Form_ee_quotientLogical :
forall (G : obGenerator) (param : Yoneda00_Param_F G) (form : {form : Yoneda00_Form_F G | sval Yoneda10_FormParam_F G form = param}) (param' : Yoneda00_Param_F G)
  (form' : {form0 : Yoneda00_Form_F G | sval Yoneda10_FormParam_F G form0 = param'}),
sval form = sval form' ->
forall (G0 : obGenerator) (param0 : Yoneda00_Param_View (Parameter0 G) G0) (form0 : 'Generator ( G0 ~> G @_ param0 )),
sval (sval (Yoneda10_Form_ee G param form) G0 param0 form0) = sval (sval (Yoneda10_Form_ee G param' form') G0 param0 form0))
(Yoneda10_Form_ee_morphism :
forall (G G' : obGenerator) (g : 'Generator( G' ~> G )) (param : Yoneda00_Param_F G) (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param) (G'' : obGenerator)
  (param' : Yoneda00_Param_View (Parameter0 G') G'') (form' : 'Generator ( G'' ~> G' @_ param' )),
sval (sval (Yoneda10_Form_ee G param form) G'' (param' o>Parametrizator Parameter1 g) (form' o>GeneratorAtParam g)) =
sval (sval (Yoneda10_Form_ee G' (g o>Generator_[sval Yoneda01_Param_F] param) (g o>GeneratorAtParam_[sval (Yoneda01_AtParam_(Yoneda10_FormParam_F))] form)) G'' param' form')),
Yoneda10_Form_data Yoneda10_FormParam_F Yoneda10_FormParam_E (Yoneda10_Param_PolyTransf_default Heq_param Yoneda10_Param_ee0_morphism).
Proof.
  intros. unshelve eexists.
  - intros G param form; simpl. unshelve eexists.
    + exact: (sval (sval (Yoneda10_Form_ee G param form) _ _ unitGenerator_AtParam)).
    + abstract (rewrite  [LHS](proj2_sig (sval (Yoneda10_Form_ee G param form) _ _ _));
                rewrite Heq_param_ee; reflexivity).
  - abstract (split; [ move; simpl; intros G param G' g form;
             rewrite [LHS](proj1 (proj2_sig (Yoneda10_Form_ee G param form))) /=;
                     rewrite -[RHS]Yoneda10_Form_ee_morphism;
             apply: (proj2 (proj2_sig (Yoneda10_Form_ee G param form))); simpl;
              rewrite -[LHS]unitGenerator_polyGenerator;
               exact: polyGenerator_unitGenerator
            | move; simpl; intros G param form param' form' Heq;
              apply: Yoneda10_Form_ee_quotientLogical; assumption ]).
Defined.

Definition Yoneda10_Form_Forget :
forall (Yoneda00_Form_F : obGenerator -> Type)
(Yoneda01_Form_F :
{Yoneda01
: forall G G' : obGenerator,
  'Generator( G' ~> G ) -> Yoneda00_Form_F G -> Yoneda00_Form_F G' |
Yoneda01_functor Yoneda01})
(Yoneda00_Param_F : obGenerator -> Type)
(Yoneda01_Param_F :
{Yoneda01
: forall G G' : obGenerator,
  'Generator( G' ~> G ) -> Yoneda00_Param_F G -> Yoneda00_Param_F G' |
Yoneda01_functor Yoneda01})
(Yoneda10_FormParam_F :
{Yoneda10 : forall G : obGenerator, Yoneda00_Form_F G -> Yoneda00_Param_F G |
Yoneda10_natural Yoneda01_Form_F Yoneda01_Param_F Yoneda10})
(Yoneda00_Param_SubstF : obGenerator -> Type)
(Yoneda01_Param_SubstF :
{Yoneda01
: forall G G' : obGenerator,
  'Generator( G' ~> G ) ->
  Yoneda00_Param_SubstF G -> Yoneda00_Param_SubstF G' |
Yoneda01_functor Yoneda01})
(Yoneda10_Param_Forget :
{Yoneda10
: forall G : obGenerator, Yoneda00_Param_SubstF G -> Yoneda00_Param_F G |
Yoneda10_natural Yoneda01_Param_SubstF Yoneda01_Param_F Yoneda10})
(Yoneda10_Param_Forget' :
{Yoneda10
: forall G : obGenerator, Yoneda00_Param_SubstF G -> Yoneda00_Param_F G |
 Yoneda10_natural Yoneda01_Param_SubstF Yoneda01_Param_F Yoneda10})
(Heq_subst : forall G param, sval Yoneda10_Param_Forget' G param = sval Yoneda10_Param_Forget G param),
  Yoneda10_Form_data
   (Yoneda10_FormParam_Subst Yoneda10_FormParam_F Yoneda10_Param_Forget')
   Yoneda10_FormParam_F Yoneda10_Param_Forget.
Proof.
  intros. unshelve eexists.
  - intros G param form . exists (snd (sval (sval form))).
    abstract(rewrite -[LHS](proj2_sig (sval form)); rewrite Heq_subst;
             congr (sval Yoneda10_Param_Forget); exact: (proj2_sig form)).
  - abstract (split; [move; simpl; intros; reflexivity
                     | move; simpl; intros; congr (snd (sval _ )); assumption] ).
Defined.

Definition Yoneda10_Form_Remember :
forall (Yoneda00_Form_F : obGenerator -> Type) (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F) (Yoneda00_Param_F : obGenerator -> Type) (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
  (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F) (Yoneda00_Param_SubstF : obGenerator -> Type)
  (Yoneda01_Param_SubstF : Yoneda01_data Yoneda00_Param_SubstF) (Yoneda10_Param_Forget : Yoneda10_data Yoneda01_Param_SubstF Yoneda01_Param_F),
forall Yoneda10_Param_Forget'
  (Heq_subst : forall G param, sval Yoneda10_Param_Forget' G param = sval Yoneda10_Param_Forget G param),
forall (Yoneda00_Form_L : obGenerator -> Type) (Yoneda01_Form_L : Yoneda01_data Yoneda00_Form_L) (Yoneda00_Param_L : obGenerator -> Type) (Yoneda01_Param_L : Yoneda01_data Yoneda00_Param_L)
  (Yoneda10_FormParam_L : Yoneda10_data Yoneda01_Form_L Yoneda01_Param_L)
  (Yoneda10_Param_ll_ : Yoneda10_data Yoneda01_Param_L Yoneda01_Param_SubstF),
forall (Yoneda10_Param_ll : Yoneda10_data Yoneda01_Param_L Yoneda01_Param_F) (Yoneda10_Form_ll : Yoneda10_Form_data Yoneda10_FormParam_L Yoneda10_FormParam_F Yoneda10_Param_ll),
forall (Heq_param : forall G param, sval Yoneda10_Param_ll G param
                              = sval (Yoneda10_Param_PolyCoMod Yoneda10_Param_ll_ Yoneda10_Param_Forget) G param),
Yoneda10_Form_data Yoneda10_FormParam_L (Yoneda10_FormParam_Subst Yoneda10_FormParam_F Yoneda10_Param_Forget') Yoneda10_Param_ll_ .
Proof.
  intros. unshelve eexists.
  - intros G param form. unshelve eexists.
    + unshelve eexists.
      * refine (  (sval Yoneda10_Param_ll_ G param) , (sval (sval Yoneda10_Form_ll _ _ form))).
      * abstract (simpl; rewrite [RHS](proj2_sig (sval Yoneda10_Form_ll _ _ _ )); rewrite Heq_subst Heq_param; reflexivity).
    + abstract (simpl; reflexivity).
  - abstract (split; [ move; simpl; intros; apply: Yoneda00_Form_Subst_quotientLogical; simpl;
                       (*TODO: HERE*) rewrite [X in X = _](proj1 (proj2_sig Yoneda10_Form_ll)); reflexivity
                     | move; simpl; intros; apply: Yoneda00_Form_Subst_quotientLogical; simpl;
                       apply: (proj2 (proj2_sig Yoneda10_Form_ll)); assumption  ]).
Defined.

Definition Yoneda10_Param_Formatting :
forall (Yoneda00_Form_F : obGenerator -> Type)
(Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F)
(Yoneda00_Param_F : obGenerator -> Type)
(Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
(Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F)
(Yoneda00_Form_E : obGenerator -> Type)
(Yoneda01_Form_E : Yoneda01_data Yoneda00_Form_E)
(Yoneda00_Param_E : obGenerator -> Type)
(Yoneda01_Param_E : Yoneda01_data Yoneda00_Param_E)
(Yoneda10_FormParam_E : Yoneda10_data Yoneda01_Form_E Yoneda01_Param_E)
(Yoneda10_Param_ff : Yoneda10_data Yoneda01_Param_E Yoneda01_Param_F)
(Yoneda10_Form_ff : Yoneda10_Form_data Yoneda10_FormParam_E Yoneda10_FormParam_F Yoneda10_Param_ff),
Yoneda10_data (Yoneda01_Form_Subst Yoneda10_FormParam_E (Yoneda10_Id Yoneda01_Param_E)) (Yoneda01_Form_Subst Yoneda10_FormParam_F (Yoneda10_Id Yoneda01_Param_F)).
Proof.
  intros. unshelve eexists.
  - intros G param_form.
    have [:blurb] form := (sval Yoneda10_Form_ff G (fst (sval param_form)) blurb);
                            first (by exists (snd (sval param_form)); abstract (symmetry; exact: (proj2_sig param_form))).
    exists (sval Yoneda10_Param_ff G (fst (sval param_form)), (sval form)).
    abstract (simpl; symmetry; exact: (proj2_sig form)).
  - abstract (move; simpl; intros; apply: Yoneda00_Form_Subst_quotientLogical; simpl;
              (*TODO: HERE*) rewrite [LHS](proj1 (proj2_sig Yoneda10_Form_ff));
              apply: (proj2 (proj2_sig Yoneda10_Form_ff)); first (by reflexivity); simpl; reflexivity).
Defined.
End Senses_morCoMod.
(** # #
#+END_SRC

** Grammar of the morphisms , which carry the sense-decodings

  TODO: in some alternative refined presentation , the inductive-type-family for the form-morphisms shall be able to carry the parametrizator-objects codes ...

#+BEGIN_SRC coq :exports both :results silent # # **)
Reserved Notation "''CoMod' (  F'  ~>  F  @_  Yoneda10_Param_ff  @^  Yoneda10_Form_ff  )" (at level 0).
Reserved Notation "''CoMod_' (  F'  ~>  F  @_  Yoneda10_Param_ff  )" (at level 0).

Inductive morCoMod : forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
                       (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E),
    forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
      (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F),
    forall Yoneda10_Param_ff (Yoneda10_Form_ff : Yoneda10_Form_data Yoneda10_FormParam_E Yoneda10_FormParam_F Yoneda10_Param_ff), Type :=

(** -----cuts to be eliminated----- **)
| PolyCoMod : forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
                (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F),
    forall Yoneda00_Form_F' Yoneda01_Form_F' Yoneda00_Param_F' Yoneda01_Param_F' Yoneda10_FormParam_F'
      (F' : @obCoMod Yoneda00_Form_F' Yoneda01_Form_F' Yoneda00_Param_F' Yoneda01_Param_F' Yoneda10_FormParam_F'),
    forall Yoneda10_Param_ff' Yoneda10_Form_ff'
      (ff' : 'CoMod( F' ~> F @_ Yoneda10_Param_ff' @^ Yoneda10_Form_ff' )),
    forall Yoneda00_Form_F'' Yoneda01_Form_F'' Yoneda00_Param_F'' Yoneda01_Param_F'' Yoneda10_FormParam_F''
      (F'' : @obCoMod Yoneda00_Form_F'' Yoneda01_Form_F'' Yoneda00_Param_F'' Yoneda01_Param_F'' Yoneda10_FormParam_F''),
    forall Yoneda10_Param_ff_ Yoneda10_Form_ff_
      (ff_ : 'CoMod( F'' ~> F' @_ Yoneda10_Param_ff_ @^ Yoneda10_Form_ff_ )),
      'CoMod( F'' ~> F @_ (Yoneda10_Param_PolyCoMod Yoneda10_Param_ff_ Yoneda10_Param_ff')
                  @^ (Yoneda10_Form_PolyCoMod Yoneda10_Form_ff' Yoneda10_Form_ff_) )

(** ----solution morphisms---- **)
| UnitCoMod : forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
                (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F),
    'CoMod( F ~> F @_ Yoneda10_UnitCoMod_Param Yoneda01_Param_F @^ Yoneda10_UnitCoMod Yoneda10_FormParam_F )

| View1 : forall (G H : obGenerator) (g : 'Generator( H ~> G )),
    'CoMod( View H ~> View G @_ Yoneda10_Param_View1 (Parameter1 g) @^ Yoneda10_Form_View1 g )

| ViewedFunctor1_default : forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
                             (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F)
                             (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
      (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E)
      (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
    forall Yoneda10_Param_ff0 (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff0 )),
    forall Yoneda10_Param_ff Yoneda10_Form_ff (ff : 'CoMod( E ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff ))
      (Heq_param :  forall G param, sval Yoneda10_Param_ff G param = sval Yoneda10_Param_ff0 G param),
      'CoMod( ViewedFunctor_default E Param_E ~> ViewedFunctor_default F Param_F
                                    @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff )

| UnitViewedFunctor_default : forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
                                (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F)
                                (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
      (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E),
    forall Yoneda10_Param_ff Yoneda10_Form_ff
      (ff : 'CoMod( E ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff )),
      'CoMod( E ~> ViewedFunctor_default F Param_F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff )

| PolyElement_default :
    forall Yoneda00_Form_F (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F) Yoneda00_Param_F (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)  (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F),
    forall (isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F)
      (isFiniteness_FormParam_F : Finiteness.isFiniteness_FormParam_ Yoneda10_FormParam_F),
    forall (Yoneda10_Param_param_ : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F )
      (Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          (**MEMO: when the parametrization-functor is not full functor ,
             then [Yoneda10_Param_param_ G param] is more data than [param : Yoneda00_Param_F G] ... *)
          param = sval (Yoneda10_Param_param_ G param) G (@unitParametrizator (Parameter0 G)) ),
    forall (Yoneda10_Param_param_morphism : (**TODO: reverse equality ? *)
         forall G (param : Yoneda00_Param_F G),
         forall (param_ : Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F )
           (Heq_param :  param = sval param_ G (@unitParametrizator (Parameter0 G)) ),
         forall G' (param' : Yoneda00_Param_View (Parameter0 G) G')
           G'' (param'' : Yoneda00_Param_View (Parameter0 G') G''),
           sval (Yoneda10_Param_param_ G param) G'' (param'' o>Parametrizator param') =
           sval (Yoneda10_Param_param_ G' (sval param_ G' param')) G'' param''),
     forall (G : obGenerator) (param : Yoneda00_Param_F G) (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
        'CoMod( View G ~> ViewingFunctor_default isFiniteness_Param_F isFiniteness_FormParam_F  @_ Yoneda10_Param_param_ G param
                   @^ Yoneda10_Form_PolyElement_default Heq_param form)

| PolyTransf_default :
    forall Yoneda00_Form_F (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F) Yoneda00_Param_F (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)  (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F),
    forall (isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F)
      (isFiniteness_FormParam_F : Finiteness.isFiniteness_FormParam_ Yoneda10_FormParam_F),
    forall (Yoneda10_Param_param_ : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F )
      (Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          param = sval (Yoneda10_Param_param_ G param) G (@unitParametrizator (Parameter0 G)) ),
    forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
      (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E)
      (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
    forall (Yoneda10_Param_ee0 : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_E)
      (param_ee0_ : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          'CoMod_( View_Param (Parameter0 G) ~> Param_E
                       @_ (Yoneda10_Param_ee0 G param) )),
    forall  (Yoneda10_Param_ee : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                            (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
           Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_E)
       (Yoneda10_Form_ee : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                            (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
          Yoneda10_Form_data (Yoneda10_FormParam_View G) Yoneda10_FormParam_E (Yoneda10_Param_ee G param form))
       (Heq_param_ee : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                            (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
           forall G' param', sval (Yoneda10_Param_ee G param form) G' param' = sval (Yoneda10_Param_ee0 G param) G' param')
       (Yoneda10_Param_ee0_morphism : (**TODO: reverse equality ? *)
          forall G (param : Yoneda00_Param_F G),
          forall (param_ : Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F )
            (Heq_param :  param = sval param_ G (@unitParametrizator (Parameter0 G)) ),
          forall G'  (param' : Yoneda00_Param_View (Parameter0 G) G')
            G'' (param'' : Yoneda00_Param_View (Parameter0 G') G''),
            sval (Yoneda10_Param_ee0 G param) G'' (param'' o>Parametrizator param') =
            sval (Yoneda10_Param_ee0 G' (sval param_ G' param')) G'' param'')
       (Yoneda10_Form_ee_quotientLogical :
         forall G param form param' form', sval form = sval form' -> forall G0 param0 form0,
             sval (sval (Yoneda10_Form_ee G param form) G0 param0 form0)
             = sval (sval (Yoneda10_Form_ee G param' form')  G0 param0 form0))
      (Yoneda10_Form_ee_morphism :
         forall (G G' : obGenerator) (g : 'Generator( G' ~> G )) (param : Yoneda00_Param_F G)
           (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
         forall (G'' : obGenerator) (param' : (Yoneda00_Param_View (Parameter0 G')) G'')
           (form' : Yoneda00_AtParam_ (Yoneda10_FormParam_View G') param'),
           sval (sval (Yoneda10_Form_ee G param form)
                      G'' (param' o>Parametrizator (Parameter1 g))
                      (form' o>GeneratorAtParam g))
           = sval (sval (Yoneda10_Form_ee G' (g o>Generator_[sval Yoneda01_Param_F] param)
                                          (g o>GeneratorAtParam_[sval (Yoneda01_AtParam_(Yoneda10_FormParam_F))] form))
                         G'' param' form'))
      (ee_ : forall (G : obGenerator) (param : Yoneda00_Param_F G)
              (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
          'CoMod( View G ~> E
                       @_ (Yoneda10_Param_ee G param form) @^ (Yoneda10_Form_ee G param form))),

      'CoMod( ViewingFunctor_default isFiniteness_Param_F isFiniteness_FormParam_F ~> ViewedFunctor_default E Param_E
                                     @_ (Yoneda10_Param_PolyTransf_default Heq_param Yoneda10_Param_ee0_morphism)
                                     @^ (Yoneda10_Form_PolyTransf_default Heq_param Yoneda10_Param_ee0_morphism Heq_param_ee Yoneda10_Form_ee_quotientLogical Yoneda10_Form_ee_morphism) )

(**TODO: common-colimiting when into viewed-functor , but not now for this default viewing-data
   | PolyTransf_default_common :
   | PolyTransf_Param_default_common :   **)

| Forget :
 forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
   (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F)
   (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
 forall Yoneda00_Param_SubstF Yoneda01_Param_SubstF
   (Param_SubstF : @obCoMod_Param Yoneda00_Param_SubstF Yoneda01_Param_SubstF),
 forall Yoneda10_Param_Forget (param_Forget : 'CoMod_( Param_SubstF ~> Param_F @_ Yoneda10_Param_Forget )),
 forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
   (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E),
 forall Yoneda10_Param_ee Yoneda10_Form_ee
   (ee : 'CoMod( F ~> E @_ Yoneda10_Param_ee @^ Yoneda10_Form_ee )),
 forall (Yoneda10_Param_Forget' : Yoneda10_data Yoneda01_Param_SubstF Yoneda01_Param_F)
   (Heq_subst : forall G param, sval Yoneda10_Param_Forget' G param = sval Yoneda10_Param_Forget G param),
   'CoMod( Subst F Param_F Param_SubstF Yoneda10_Param_Forget' ~> E
                 @_ (Yoneda10_Param_PolyCoMod Yoneda10_Param_Forget Yoneda10_Param_ee)
                 @^ (Yoneda10_Form_PolyCoMod Yoneda10_Form_ee
                                             (Yoneda10_Form_Forget Yoneda10_FormParam_F Heq_subst)) )

| Remember :
 forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
   (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F)
   (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
 forall Yoneda00_Param_SubstF Yoneda01_Param_SubstF
   (Param_SubstF : @obCoMod_Param Yoneda00_Param_SubstF Yoneda01_Param_SubstF),
 forall Yoneda10_Param_Forget (param_Forget : 'CoMod_( Param_SubstF ~> Param_F @_ Yoneda10_Param_Forget )),
 forall (L : obGenerator) Yoneda10_Param_ll Yoneda10_Form_ll
   (ll : 'CoMod( View L ~> F @_ Yoneda10_Param_ll @^ Yoneda10_Form_ll )),
 forall (**MEMO: when the generating parametrizator-functor is full then
      this polyelement is the same as one (decidable) single element [param : Yoneda01_Param_SubstF (Parameter0 L)] *)
   (Yoneda10_Param_ll_ : Yoneda10_data (Yoneda01_Param_View (Parameter0 L)) Yoneda01_Param_SubstF)
   (Heq_param : forall G param, sval Yoneda10_Param_ll G param
                           = sval (Yoneda10_Param_PolyCoMod Yoneda10_Param_ll_ Yoneda10_Param_Forget) G param),
 forall (Yoneda10_Param_Forget' : Yoneda10_data Yoneda01_Param_SubstF Yoneda01_Param_F)
   (Heq_subst : forall G param, sval Yoneda10_Param_Forget' G param = sval Yoneda10_Param_Forget G param),
   'CoMod( View L  ~> Subst F Param_F Param_SubstF Yoneda10_Param_Forget'
              @_ Yoneda10_Param_ll_ @^ Yoneda10_Form_Remember Heq_subst Yoneda10_Form_ll Heq_param )

where "''CoMod' ( F' ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff )" :=
        (@morCoMod _ _ _ _ _ F' _ _ _ _ _ F Yoneda10_Param_ff Yoneda10_Form_ff) : poly_scope

with morCoMod_Param : forall Yoneda00_Param_E Yoneda01_Param_E (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
 forall Yoneda00_Param_F Yoneda01_Param_F (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
 forall Yoneda10_Param_ff : Yoneda10_data Yoneda01_Param_E Yoneda01_Param_F, Type :=

(** -----cuts to be eliminated----- **)
| PolyCoMod_Param : forall Yoneda00_Param_F Yoneda01_Param_F (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F)
  Yoneda00_Param_F' Yoneda01_Param_F' (Param_F' : @obCoMod_Param Yoneda00_Param_F' Yoneda01_Param_F')
  Yoneda10_Param_ff'  (param_ff' : 'CoMod_( Param_F' ~> Param_F @_ Yoneda10_Param_ff')),
  forall Yoneda00_Param_F'' Yoneda01_Param_F'' (Param_F'' : @obCoMod_Param Yoneda00_Param_F'' Yoneda01_Param_F''),
  forall Yoneda10_Param_ff_ (param_ff_ : 'CoMod_( Param_F'' ~> Param_F' @_ Yoneda10_Param_ff_ )),
    'CoMod_( Param_F'' ~> Param_F @_ Yoneda10_Param_PolyCoMod Yoneda10_Param_ff_ Yoneda10_Param_ff' )

(** ----solution morphisms---- **)
| UnitCoMod_Param : forall Yoneda00_Param_F Yoneda01_Param_F (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    'CoMod_( Param_F ~> Param_F @_ Yoneda10_UnitCoMod_Param Yoneda01_Param_F )

| View1_Param : forall (G : obGenerator) (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
    forall (Q : obParametrizator) (p : 'Parametrizator( P ~> Q )),
      'CoMod_( View_Param P ~> View_Param Q @_ Yoneda10_Param_View1 p )

| ViewedFunctor1_Param_default : forall Yoneda00_Param_F Yoneda01_Param_F
                                   (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda00_Param_E Yoneda01_Param_E
      (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
    forall Yoneda10_Param_ff (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff )),
      'CoMod_( ViewedFunctor_Param_default Param_E ~> ViewedFunctor_Param_default Param_F
                                           @_ Yoneda10_Param_ff )

| UnitViewedFunctor_Param_default : forall Yoneda00_Param_F Yoneda01_Param_F
                                      (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda00_Param_E Yoneda01_Param_E
      (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
    forall Yoneda10_Param_ff (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff )),
      'CoMod_( Param_E ~> ViewedFunctor_Param_default Param_F @_ Yoneda10_Param_ff )

| PolyElement_Param_default :
    forall Yoneda00_Param_F (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F),
    forall (isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F),
    forall (Yoneda10_Param_param_ : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                                 (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_F )
      (Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                     (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          param = sval (Yoneda10_Param_param_ G param P is_Parameter0_P)
                       G (is_Parameter0_transp_rev_codom is_Parameter0_P (@unitParametrizator (Parameter0 G))) ),
    forall (Yoneda10_Param_param_morphism : (**TODO: reverse equality ? *)
         forall G (param : Yoneda00_Param_F G) (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
         forall (param_ : Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_F )
           (Heq_param :  param = sval param_ G (is_Parameter0_transp_rev_codom is_Parameter0_P (@unitParametrizator (Parameter0 G)))),
         forall G'  (param' : Yoneda00_Param_View P G')
           G'' (param'' : Yoneda00_Param_View (Parameter0 G') G''),
           sval (Yoneda10_Param_param_ G param P is_Parameter0_P) G'' (param'' o>Parametrizator param') =
           sval (Yoneda10_Param_param_ G' (sval param_ G' param') (Parameter0 G') (Is_Parameter0 G')) G'' param'') ,
    forall (G : obGenerator) (param : Yoneda00_Param_F G) (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
      'CoMod_( View_Param P ~> ViewingFunctor_Param_default isFiniteness_Param_F @_ Yoneda10_Param_param_ G param P is_Parameter0_P )

| PolyTransf_Param_default :
    forall Yoneda00_Param_F (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F),
    forall (isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F),
    forall (Yoneda10_Param_param_ : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                                 (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_F )
      (Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                     (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          param = sval (Yoneda10_Param_param_ G param P is_Parameter0_P)
                       G (is_Parameter0_transp_rev_codom is_Parameter0_P (@unitParametrizator (Parameter0 G))) ),
    forall Yoneda00_Param_E Yoneda01_Param_E
      (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
    forall (Yoneda10_Param_ee : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                             (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_E)
      (Yoneda10_Param_ee_morphism : (**TODO: reverse equality ? *)
         forall G (param : Yoneda00_Param_F G) (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
         forall (param_ : Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_F )
           (Heq_param :  param = sval param_ G (is_Parameter0_transp_rev_codom is_Parameter0_P (@unitParametrizator (Parameter0 G)))),
         forall G'  (param' : Yoneda00_Param_View P G')
           G'' (param'' : Yoneda00_Param_View (Parameter0 G') G''),
           sval (Yoneda10_Param_ee G param P is_Parameter0_P) G'' (param'' o>Parametrizator param') =
           sval (Yoneda10_Param_ee G' (sval param_ G' param') (Parameter0 G') (Is_Parameter0 G')) G'' param'')
      (param_ee_ : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                     (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          'CoMod_( View_Param P ~> Param_E @_ (Yoneda10_Param_ee G param P is_Parameter0_P) )),
      'CoMod_( ViewingFunctor_Param_default isFiniteness_Param_F ~> ViewedFunctor_Param_default Param_E
                                     @_ Yoneda10_Param_PolyTransf_default_Param Heq_param Yoneda10_Param_ee_morphism )

| Formatting :
    forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
      (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E)
      (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
    forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
      (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F)
      (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda10_Param_ff0 (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff0 )),
    forall Yoneda10_Param_ff Yoneda10_Form_ff
      (ff : 'CoMod( E ~> F @_ (* Yoneda10_Param_project <o *) Yoneda10_Param_ff @^ Yoneda10_Form_ff )),
      'CoMod_( Format E Param_E ~> Format F Param_F @_ (Yoneda10_Param_Formatting Yoneda10_Form_ff) )

where "''CoMod_' ( F' ~> F @_ Yoneda10_Param_ff )" :=
        (@morCoMod_Param _ _ F' _ _ F Yoneda10_Param_ff) : poly_scope .

Notation "''CoMod' ( F' ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff )" :=
  (@morCoMod _ _ _ _ _ F' _ _ _ _ _ F Yoneda10_Param_ff Yoneda10_Form_ff) : poly_scope.

Notation "''CoMod' (  F'  ~>  F  )" := (@morCoMod _ _ _ _ _ F' _ _ _ _ _ F _ _)
       (at level 0, only parsing) : poly_scope.

Notation "''CoMod_' ( F' ~> F @_ Yoneda10_Param_ff )" :=
        (@morCoMod_Param _ _ F' _ _ F Yoneda10_Param_ff) : poly_scope .

Notation "''CoMod_' (  F'  ~>  F  )" := (@morCoMod_Param _ _ F' _ _ F _)
       (at level 0, only parsing) : poly_scope.

Notation "ff_ o>CoMod_ ff'" := (@PolyCoMod_Param _ _ _ _ _ _ _ ff' _ _ _ _ ff_)
               (at level 40 , ff' at next level , left associativity) : poly_scope.

Notation "@ ''UnitCoMod_' Param_F" := (@UnitCoMod_Param _ _ Param_F)
                                 (at level 10, Param_F at next level, only parsing) : poly_scope.

Notation "''UnitCoMod_'" := (@UnitCoMod_Param _ _ _) (at level 0) : poly_scope.

Notation "''View1_' is_Parameter0_P p" := (@View1_Param _ _ is_Parameter0_P _ p)
                   (at level 10, is_Parameter0_P , p at next level) : poly_scope.

Notation "''ViewedFunctor1_' param_ff" := (@ViewedFunctor1_Param_default _ _ _ _ _ _ _ param_ff)
                   (at level 10, param_ff at next level) : poly_scope.

Notation "param_ff o>CoMod_ 'UnitViewedFunctor_" :=
  (@UnitViewedFunctor_Param_default  _ _ _ _ _ _ _ param_ff)
    (at level 4, right associativity) : poly_scope.

Notation "''PolyElement_' param @_ isFiniteness_Param_F , is_Parameter0_P , Heq_param , Yoneda10_Param_param_morphism"
  := (@PolyElement_Param_default _ _ isFiniteness_Param_F _ Heq_param Yoneda10_Param_param_morphism _ param _ is_Parameter0_P)
       (at level 10, param , isFiniteness_Param_F , is_Parameter0_P , Heq_param, Yoneda10_Param_param_morphism at next level) : poly_scope.

Notation "''PolyElement_' param @_ isFiniteness_Param_F"
  := (@PolyElement_Param_default _ _ isFiniteness_Param_F _ _ _ _ param _ _)
       (at level 10, param , isFiniteness_Param_F at next level) : poly_scope.

Notation "[[_  param_ee_  @_  isFiniteness_Param_F  ,  Heq_param , Yoneda10_Param_ee_morphism  ]]" :=
  (@PolyTransf_Param_default _ _ isFiniteness_Param_F _ Heq_param _ _ _ _ Yoneda10_Param_ee_morphism param_ee_ )
    (at level 0, param_ee_ , isFiniteness_Param_F , Heq_param , Yoneda10_Param_ee_morphism at level 10) : poly_scope.

Notation "[[_  param_ee_  @_  isFiniteness_Param_F  ]]" :=
  (@PolyTransf_Param_default _ _ isFiniteness_Param_F _ _ _ _ _ _ _ param_ee_ )
    (at level 0, param_ee_ , isFiniteness_Param_F at level 10) : poly_scope.

Notation "''Formatting' ff @_ param_ff" :=
  (@Formatting _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ param_ff _ _ ff)
    (at level 10, ff , param_ff at next level) : poly_scope.

Notation "ff_ o>CoMod ff'" :=
  (@PolyCoMod _ _ _ _ _ _ _ _ _ _ _ _ _ _ ff' _ _ _ _ _ _ _ _ ff_ )
    (at level 40, left associativity) : poly_scope.

Notation "@ ''UnitCoMod' F" := (@UnitCoMod _ _ _ _ _ F)
                                 (at level 10, F at next level, only parsing) : poly_scope.

Notation "''UnitCoMod'" := (@UnitCoMod _ _ _ _ _ _) (at level 0) : poly_scope.

Notation "''View1' g" := (@View1 _ _ g)
                   (at level 10, g at next level) : poly_scope.

Notation "''ViewedFunctor1' ff @_ Heq_param = param_ff" :=
  (@ViewedFunctor1_default _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ param_ff _ _ ff Heq_param)
    (at level 10, ff , Heq_param , param_ff at next level) : poly_scope.

Notation "''ViewedFunctor1' ff @_ param_ff" :=
  (@ViewedFunctor1_default _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ param_ff _ _ ff _)
    (at level 10, ff ,  param_ff at next level) : poly_scope.

Notation "ff o>CoMod 'UnitViewedFunctor @_ Param_F" :=
  (@UnitViewedFunctor_default _ _ _ _ _ _ Param_F _ _ _ _ _ _ _ _ ff)
    (at level 4,  right associativity) : poly_scope.

Notation "''PolyElement'  form  @_  isFiniteness_Param_F , Heq_param , Yoneda10_Param_param_morphism @^  isFiniteness_FormParam_F"
  := (@PolyElement_default _ _ _ _ _ isFiniteness_Param_F isFiniteness_FormParam_F _ Heq_param  Yoneda10_Param_param_morphism _ _ form)
       (at level 10, form , isFiniteness_Param_F , Heq_param , Yoneda10_Param_param_morphism , isFiniteness_FormParam_F at next level) : poly_scope.

Notation "''PolyElement'  form  @_ isFiniteness_Param_F @^  isFiniteness_FormParam_F"
  := (@PolyElement_default _ _ _ _ _ isFiniteness_Param_F isFiniteness_FormParam_F _ _ _ _ _ form)
       (at level 10, form , isFiniteness_Param_F, isFiniteness_FormParam_F at next level) : poly_scope.

Notation "[[  ee_  @_ param_ee0_ , isFiniteness_Param_F , Heq_param , Heq_param_ee , Yoneda10_Param_ee0_morphism  @^ isFiniteness_FormParam_F , Yoneda10_Form_ee_quotientLogical , Yoneda10_Form_ee_morphism  ]]" :=
  (@PolyTransf_default _ _ _ _ _ isFiniteness_Param_F isFiniteness_FormParam_F _ Heq_param _ _ _ _ _ _ _ _ param_ee0_ _ _ Heq_param_ee Yoneda10_Param_ee0_morphism Yoneda10_Form_ee_quotientLogical Yoneda10_Form_ee_morphism ee_)
    (at level 0 , ee_ , param_ee0_ , isFiniteness_Param_F , Heq_param , Heq_param_ee , Yoneda10_Param_ee0_morphism , isFiniteness_FormParam_F , Yoneda10_Form_ee_quotientLogical , Yoneda10_Form_ee_morphism at level 10) : poly_scope.

Notation "[[  ee_  @_ param_ee0_ , isFiniteness_Param_F @^  isFiniteness_FormParam_F  ]]" :=
  (@PolyTransf_default _ _ _ _ _ isFiniteness_Param_F isFiniteness_FormParam_F _ _ _ _ _ _ _ _ _ _ param_ee0_ _ _ _ _ _ _ ee_)
    (at level 0, ee_ , param_ee0_ , isFiniteness_Param_F , isFiniteness_FormParam_F at level 10) : poly_scope.

Notation "''Forget' @_ Heq_subst = param_Forget o>CoMod ee" :=
  (@Forget _ _ _ _ _ _ _ _ _ _ _ param_Forget _ _ _ _ _ _ _ _ ee _ Heq_subst)
    (at level 10, Heq_subst , param_Forget, ee at next level) : poly_scope.

Notation "''Forget' @_ param_Forget o>CoMod ee" :=
  (@Forget _ _ _ _ _ _ _ _ _ _ _ param_Forget _ _ _ _ _ _ _ _ ee _ _)
    (at level 10, param_Forget, ee at next level) : poly_scope.

Notation "<<  ll  @_  Heq_param  =  Yoneda10_Param_ll_  ,  Heq_subst = param_Forget  >>" :=
  (@Remember _ _ _ _ _ _ _ _ _ _ _ param_Forget _ _ _ ll Yoneda10_Param_ll_ Heq_param _ Heq_subst)
    (at level 0, ll, Heq_param , Yoneda10_Param_ll_ , Heq_subst , param_Forget at level 10) : poly_scope.

Notation "<<  ll  @_  Yoneda10_Param_ll_  ,  param_Forget  >>" :=
  (@Remember _ _ _ _ _ _ _ _ _ _ _ param_Forget _ _ _ ll Yoneda10_Param_ll_ _ _ _)
    (at level 0, ll, Yoneda10_Param_ll_ , param_Forget at level 10) : poly_scope.

Scheme morCoMod_morCoMod_Param_ind := Induction for morCoMod Sort Prop
 with  morCoMod_Param_morCoMod_ind := Induction for morCoMod_Param Sort Prop.
Combined Scheme morCoMod_morCoMod_Param_mutind from
         morCoMod_morCoMod_Param_ind, morCoMod_Param_morCoMod_ind.
Scheme  morCoMod_morCoMod_Param_rect := Induction for morCoMod Sort Type
 with  morCoMod_Param_morCoMod_rect := Induction for morCoMod_Param Sort Type.
Definition morCoMod_morCoMod_Param_mutrect P P0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 a13 a14 a15 a16 a17 :=
  pair (@morCoMod_morCoMod_Param_rect P P0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 a13 a14 a15 a16 a17)
       (@morCoMod_Param_morCoMod_rect P P0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 a13 a14 a15 a16 a17).
(** # #
#+END_SRC

* Grammatical conversions of morphisms , which infer the same sense-decoding

  As common , the grammatical conversions are classified into : the total/(multi-step) conversions , and the congruences (recursive) conversions , and the constant (non-recursive) conversions which are used in the polymorphism/cut-elimination lemma , and the constant conversions which are only for the wanted sense of modified-colimits-into-viewed-functors , and the constant conversions which are only for the confluence lemma (TODO:) , and the constant conversions which may be assumed or are derivable by using the finished cut-elimination lemma .

  In contrast , because of the embedded sense-decoding extra-indexes/arguments in the datatype-families [morCoMod] of the morphisms , the conversion-relation shall convert across two morphisms whose sense-decoding datatype-indexes/arguments are not syntactically/grammatically-the-same . But oneself does show that , by logical-deduction [convCoMod_sense_mut] , these two sense-decodings are indeed propositionally equal ( « sensible lemma » , "soundness lemma" ) .

  The converse inference is the « sense-completeness lemma » , whose deduction will lack the finished cut-elimination lemma . Such sense-completeness lemma is expected because : some sense-completeness lemma are known to hold for adjunctions and for comonad and for (cartesian) products but using the combinatorial "links" sense ( in the style of Dosen ) ; the attention is that this combinatorial "links" sense is the combinatorial essense of this ongoing (algebraic) metafunctors ( "presheaf" ) sense ; therefore those completeness lemma shall transfer . Similarly the « maximality lemma » says that any non-deductible extra conversion constructor which is assumed to hold in the sense (model) , will make any two grammatical morphisms equal ( preorder ) in the sense . Such maximality lemma which are known to hold for adjunctions and for comonad and for (cartesian) products shall transfer to this ongoing metafunctors ( "presheaf" ) sense .

  Finally , some linear total/asymptotic grade is defined on the morphisms and the tactics-automated degradation lemma shows that each of the conversion indeed degrades the redex morphism .

** Grammatical conversions of morphisms

#+BEGIN_SRC coq :exports both :results silent # # **)
Module Export Senses_convCoMod.
Lemma Yoneda10_ViewedFunctor1_default_morphism :
forall (Yoneda00_Param_F : obGenerator -> Type)
(Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
(Yoneda00_Param_E : obGenerator -> Type)
(Yoneda01_Param_E : Yoneda01_data Yoneda00_Param_E)
(Yoneda10_Param_ff0 : Yoneda10_data Yoneda01_Param_E Yoneda01_Param_F)
(Yoneda10_Param_ff : Yoneda10_data Yoneda01_Param_E Yoneda01_Param_F)
(Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_E G), sval Yoneda10_Param_ff G param = sval Yoneda10_Param_ff0 G param)
(Yoneda00_Param_D : obGenerator -> Type)
(Yoneda01_Param_D : Yoneda01_data Yoneda00_Param_D)
(Yoneda10_Param_dd0 : Yoneda10_data Yoneda01_Param_F Yoneda01_Param_D)
(Yoneda10_Param_dd : Yoneda10_data Yoneda01_Param_F Yoneda01_Param_D)
(Heq_param_dd : forall (G : obGenerator) (param : Yoneda00_Param_F G), sval Yoneda10_Param_dd G param = sval Yoneda10_Param_dd0 G param),
forall (G : obGenerator) (param : Yoneda00_Param_E G),
  sval (Yoneda10_Param_PolyCoMod Yoneda10_Param_ff Yoneda10_Param_dd) G param = sval (Yoneda10_Param_PolyCoMod Yoneda10_Param_ff0 Yoneda10_Param_dd0) G param.
Proof.
  intros; simpl; rewrite Heq_param Heq_param_dd; reflexivity.
Qed.

(* next 4 grouped *)
Lemma Yoneda10_PolyTransf_default_morphism_Heq_param_ee :
 forall (Yoneda00_Form_F : obGenerator -> Type)
(Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F)
(Yoneda00_Param_F : obGenerator -> Type)
(Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
(Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F)
(Yoneda00_Param_E : obGenerator -> Type)
(Yoneda01_Param_E : Yoneda01_data Yoneda00_Param_E)
(Yoneda10_Param_ee0 : forall G : obGenerator, Yoneda00_Param_F G -> Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_E)
(Yoneda10_Param_ee : forall  (G : obGenerator) (param : Yoneda00_Param_F G) (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param), Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_E)
(Heq_param_ee :
forall  (G : obGenerator) (param : Yoneda00_Param_F G) (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param) (G' : obGenerator) (param' : Yoneda00_Param_View (Parameter0 G) G'),
sval (Yoneda10_Param_ee G param form) G' param' = sval (Yoneda10_Param_ee0 G param) G' param')
(Yoneda00_Param_D : obGenerator -> Type)
(Yoneda01_Param_D : Yoneda01_data Yoneda00_Param_D)
(Yoneda10_Param_dd0 : Yoneda10_data Yoneda01_Param_E Yoneda01_Param_D)
(Yoneda10_Param_dd : Yoneda10_data Yoneda01_Param_E Yoneda01_Param_D)
(Heq_param_dd : forall (G : obGenerator) (param : Yoneda00_Param_E G), sval Yoneda10_Param_dd G param = sval Yoneda10_Param_dd0 G param),
forall (G : obGenerator) (param : Yoneda00_Param_F G)(form : Yoneda00_AtParam_ Yoneda10_FormParam_F param) (G' : obGenerator) (param' : Yoneda00_Param_View (Parameter0 G) G'),
  sval ((Yoneda10_Param_PolyCoMod (Yoneda10_Param_ee G param form) Yoneda10_Param_dd)) G' param' = sval (Yoneda10_Param_PolyCoMod (Yoneda10_Param_ee0 G param) Yoneda10_Param_dd0) G' param'.
Proof.
  intros; simpl. rewrite Heq_param_dd Heq_param_ee. reflexivity.
Qed.

Lemma Yoneda10_PolyTransf_default_morphism_Param_ee0_morphism :
forall (Yoneda00_Param_F : obGenerator -> Type)
(Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
(Yoneda00_Param_E : obGenerator -> Type)
(Yoneda01_Param_E : Yoneda01_data Yoneda00_Param_E)
(Yoneda10_Param_ee0 : forall G : obGenerator, Yoneda00_Param_F G -> Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_E)
(Yoneda10_Param_ee0_morphism : (**TODO: reverse equality ? *)
   forall G (param : Yoneda00_Param_F G),
   forall (param_ : Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F )
     (Heq_param :  param = sval param_ G (@unitParametrizator (Parameter0 G)) ),
   forall G'  (param' : Yoneda00_Param_View (Parameter0 G) G')
     G'' (param'' : Yoneda00_Param_View (Parameter0 G') G''),
     sval (Yoneda10_Param_ee0 G param) G'' (param'' o>Parametrizator param') =
     sval (Yoneda10_Param_ee0 G' (sval param_ G' param')) G'' param'')
(Yoneda00_Param_D : obGenerator -> Type)
(Yoneda01_Param_D : Yoneda01_data Yoneda00_Param_D)
(Yoneda10_Param_dd0 : Yoneda10_data Yoneda01_Param_E Yoneda01_Param_D),
 forall (G : obGenerator) (param : Yoneda00_Param_F G),
   forall (param_ : Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F )
     (Heq_param :  param = sval param_ G (@unitParametrizator (Parameter0 G)) ),
   forall (G' : obGenerator) (param' : Yoneda00_Param_View (Parameter0 G) G') (G'' : obGenerator) (param'' : Yoneda00_Param_View (Parameter0 G') G''),
  sval (Yoneda10_Param_PolyCoMod (Yoneda10_Param_ee0 G param) Yoneda10_Param_dd0) G'' (param'' o>Parametrizator param') =
  sval (Yoneda10_Param_PolyCoMod (Yoneda10_Param_ee0 G' (sval param_ G' param')) Yoneda10_Param_dd0) G'' param''.
Proof.
  intros; simpl. congr (sval Yoneda10_Param_dd0 _ ).
  exact: Yoneda10_Param_ee0_morphism.
Qed.

Lemma Yoneda10_PolyTransf_default_morphism_Form_ee_quotientLogical :
forall (Yoneda00_Form_F : obGenerator -> Type)
(Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F)
(Yoneda00_Param_F : obGenerator -> Type)
(Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
(Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F)
(Yoneda00_Form_E : obGenerator -> Type)
(Yoneda01_Form_E : Yoneda01_data Yoneda00_Form_E)
(Yoneda00_Param_E : obGenerator -> Type)
(Yoneda01_Param_E : Yoneda01_data Yoneda00_Param_E)
(Yoneda10_FormParam_E : Yoneda10_data Yoneda01_Form_E Yoneda01_Param_E)
(Yoneda10_Param_ee : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                       (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param), Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_E)
(Yoneda10_Form_ee : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                            (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
    Yoneda10_Form_data (Yoneda10_FormParam_View G) Yoneda10_FormParam_E (Yoneda10_Param_ee G param form))
(Yoneda10_Form_ee_quotientLogical :
forall (G : obGenerator) (param : Yoneda00_Param_F G) (form : {form : Yoneda00_Form_F G | sval Yoneda10_FormParam_F G form = param}) (param' : Yoneda00_Param_F G)
  (form' : {form0 : Yoneda00_Form_F G | sval Yoneda10_FormParam_F G form0 = param'}),
sval form = sval form' ->
forall (G0 : obGenerator) (param0 : Yoneda00_Param_View (Parameter0 G) G0) (form0 : 'Generator ( G0 ~> G @_ param0 )),
sval (sval (Yoneda10_Form_ee G param form) G0 param0 form0) = sval (sval (Yoneda10_Form_ee G param' form') G0 param0 form0))
(Yoneda00_Form_D : obGenerator -> Type)
(Yoneda01_Form_D : Yoneda01_data Yoneda00_Form_D)
(Yoneda00_Param_D : obGenerator -> Type)
(Yoneda01_Param_D : Yoneda01_data Yoneda00_Param_D)
(Yoneda10_FormParam_D : Yoneda10_data Yoneda01_Form_D Yoneda01_Param_D)
(Yoneda10_Param_dd : Yoneda10_data Yoneda01_Param_E Yoneda01_Param_D)
(Yoneda10_Form_dd : Yoneda10_Form_data Yoneda10_FormParam_E Yoneda10_FormParam_D Yoneda10_Param_dd),
forall (G : obGenerator) (param : Yoneda00_Param_F G) (form : {form : Yoneda00_Form_F G | sval Yoneda10_FormParam_F G form = param}) (param' : Yoneda00_Param_F G)
    (form' : {form0 : Yoneda00_Form_F G | sval Yoneda10_FormParam_F G form0 = param'}),
  sval form = sval form' ->
  forall (G0 : obGenerator) (param0 : Yoneda00_Param_View (Parameter0 G) G0) (form0 : 'Generator ( G0 ~> G @_ param0 )),
  sval (sval ((Yoneda10_Form_PolyCoMod Yoneda10_Form_dd (Yoneda10_Form_ee G param form))) G0 param0 form0) = sval (sval ((Yoneda10_Form_PolyCoMod Yoneda10_Form_dd (Yoneda10_Form_ee G param' form'))) G0 param0 form0).
Proof.
  intros; simpl. apply: (proj2 (proj2_sig Yoneda10_Form_dd)); simpl.
  apply:  Yoneda10_Form_ee_quotientLogical; assumption.
Qed.

Lemma Yoneda10_PolyTransf_default_morphism_Form_ee_morphism :
forall (Yoneda00_Form_F : obGenerator -> Type)
(Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F)
(Yoneda00_Param_F : obGenerator -> Type)
(Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
(Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F)
(Yoneda00_Form_E : obGenerator -> Type)
(Yoneda01_Form_E : Yoneda01_data Yoneda00_Form_E)
(Yoneda00_Param_E : obGenerator -> Type)
(Yoneda01_Param_E : Yoneda01_data Yoneda00_Param_E)
(Yoneda10_FormParam_E : Yoneda10_data Yoneda01_Form_E Yoneda01_Param_E)
(Yoneda10_Param_ee : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                       (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
    Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_E)
(Yoneda10_Form_ee : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                      (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
    Yoneda10_Form_data (Yoneda10_FormParam_View G) Yoneda10_FormParam_E (Yoneda10_Param_ee G param form))
(Yoneda10_Form_ee_morphism :
         forall (G G' : obGenerator) (g : 'Generator( G' ~> G )) (param : Yoneda00_Param_F G)
           (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
         forall (G'' : obGenerator) (param' : (Yoneda00_Param_View (Parameter0 G')) G'')
           (form' : Yoneda00_AtParam_ (Yoneda10_FormParam_View G') param'),
           sval (sval (Yoneda10_Form_ee G param form)
                      G'' (param' o>Parametrizator (Parameter1 g))
                      (form' o>GeneratorAtParam g))
           = sval (sval (Yoneda10_Form_ee G' (g o>Generator_[sval Yoneda01_Param_F] param)
                                          (g o>GeneratorAtParam_[sval (Yoneda01_AtParam_(Yoneda10_FormParam_F))] form))
                        G'' param' form'))
(Yoneda00_Form_D : obGenerator -> Type)
(Yoneda01_Form_D : Yoneda01_data Yoneda00_Form_D)
(Yoneda00_Param_D : obGenerator -> Type)
(Yoneda01_Param_D : Yoneda01_data Yoneda00_Param_D)
(Yoneda10_FormParam_D : Yoneda10_data Yoneda01_Form_D Yoneda01_Param_D)
(Yoneda10_Param_dd : Yoneda10_data Yoneda01_Param_E Yoneda01_Param_D)
(Yoneda10_Form_dd : Yoneda10_Form_data Yoneda10_FormParam_E Yoneda10_FormParam_D Yoneda10_Param_dd),
forall (G G' : obGenerator) (g : 'Generator( G' ~> G )) (param : Yoneda00_Param_F G) (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param) (G'' : obGenerator)
    (param' : Yoneda00_Param_View (Parameter0 G') G'') (form' : 'Generator( G'' ~> G' @_ param' )),
  sval (sval (Yoneda10_Form_PolyCoMod Yoneda10_Form_dd (Yoneda10_Form_ee G param form)) G'' (param' o>Parametrizator Parameter1 g) (form' o>GeneratorAtParam g)) =
  sval (sval (Yoneda10_Form_PolyCoMod Yoneda10_Form_dd (Yoneda10_Form_ee G' (g o>Generator_ param) (g o>GeneratorAtParam_[sval (Yoneda01_AtParam_(Yoneda10_FormParam_F))] form))) G'' param' form').
Proof.
  intros; simpl; apply: (proj2 (proj2_sig Yoneda10_Form_dd));
           simpl; exact: Yoneda10_Form_ee_morphism .
Qed.
(* end 4 grouped *)

Lemma Yoneda10_Remember_morphism :
forall (Yoneda00_Param_F : obGenerator -> Type)
(Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
(Yoneda00_Param_SubstF : obGenerator -> Type)
(Yoneda01_Param_SubstF : Yoneda01_data Yoneda00_Param_SubstF)
(Yoneda10_Param_Forget : Yoneda10_data Yoneda01_Param_SubstF Yoneda01_Param_F)
(L : obGenerator)
(Yoneda10_Param_ll : Yoneda10_data (Yoneda01_Param_View (Parameter0 L)) Yoneda01_Param_F)
(Yoneda10_Param_ll_ : Yoneda10_data (Yoneda01_Param_View (Parameter0 L)) Yoneda01_Param_SubstF)
(Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_View (Parameter0 L) G), sval Yoneda10_Param_ll G param = sval (Yoneda10_Param_PolyCoMod Yoneda10_Param_ll_ Yoneda10_Param_Forget) G param)
(D : obGenerator)
(d : 'Generator( D ~> L )),
forall (G : obGenerator) (param : Yoneda00_Param_View (Parameter0 D) G),
  sval (Yoneda10_Param_PolyCoMod (Yoneda10_Param_View1 (Parameter1 d)) Yoneda10_Param_ll) G param =
  sval (Yoneda10_Param_PolyCoMod (Yoneda10_Param_PolyCoMod (Yoneda10_Param_View1 (Parameter1 d)) Yoneda10_Param_ll_) Yoneda10_Param_Forget) G param.
Proof.
  intros; simpl;rewrite Heq_param; reflexivity.
Qed.

Lemma Yoneda10_PolyTransf_default'PolyElement_default :
forall (Yoneda00_Form_F : obGenerator -> Type)
(Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F)
(Yoneda00_Param_F : obGenerator -> Type)
(Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
(Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F)
(Yoneda10_Param_param_ : forall G : obGenerator, Yoneda00_Param_F G -> Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F)
(Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G), param = sval (Yoneda10_Param_param_ G param) G unitParametrizator),
forall (G : obGenerator) (param : Yoneda00_Param_F G) (form : {form : Yoneda00_Form_F G | sval Yoneda10_FormParam_F G form = param}) (param' : Yoneda00_Param_F G)
    (form' : {form0 : Yoneda00_Form_F G | sval Yoneda10_FormParam_F G form0 = param'}),
  sval form = sval form' ->
  forall (G0 : obGenerator) (param0 : Yoneda00_Param_View (Parameter0 G) G0) (form0 : 'Generator ( G0 ~> G @_ param0 )),
  sval (sval (Yoneda10_Form_PolyElement_default Heq_param form) G0 param0 form0) = sval (sval (Yoneda10_Form_PolyElement_default Heq_param form') G0 param0 form0).
Proof.
  intros until form'; intros Heq; simpl; rewrite Heq; reflexivity.
Qed.

Lemma Yoneda10_Form_PolyElement_default_morphism :
forall (Yoneda00_Form_F : obGenerator -> Type)
(Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F)
(Yoneda00_Param_F : obGenerator -> Type)
(Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
(Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F)
 (Yoneda10_Param_form_ : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F )
      (Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          param = sval (Yoneda10_Param_form_ G param) G (@unitParametrizator (Parameter0 G)) ),
forall (G G' : obGenerator) (g : 'Generator( G' ~> G )) (param : Yoneda00_Param_F G) (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param) (G'' : obGenerator)
  (param' : Yoneda00_Param_View (Parameter0 G') G'') (form' : 'Generator( G'' ~> G' @_ param' )),
sval (sval (Yoneda10_Form_PolyElement_default Heq_param form) G'' (param' o>Parametrizator Parameter1 g) (form' o>GeneratorAtParam g)) =
sval (sval (Yoneda10_Form_PolyElement_default Heq_param (g o>GeneratorAtParam_[sval (Yoneda01_AtParam_(Yoneda10_FormParam_F))] form)) G'' param' form') .
Proof.
  intros; simpl; symmetry; exact: (proj1 (proj2_sig Yoneda01_Form_F)).
Qed.

Lemma Yoneda10_Remember'Forget :
forall (Yoneda00_Param_F : obGenerator -> Type)
(Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
(Yoneda00_Param_SubstF : obGenerator -> Type)
(Yoneda01_Param_SubstF : Yoneda01_data Yoneda00_Param_SubstF)
(Yoneda10_Param_Forget : Yoneda10_data Yoneda01_Param_SubstF Yoneda01_Param_F)
(Yoneda10_Param_Forget' : {Yoneda10 : forall x : obGenerator, Yoneda00_Param_SubstF x -> Yoneda00_Param_F x | Yoneda10_natural Yoneda01_Param_SubstF Yoneda01_Param_F Yoneda10})
(Heq_subst : forall (G : obGenerator) (param : Yoneda00_Param_SubstF G), sval Yoneda10_Param_Forget' G param = sval Yoneda10_Param_Forget G param)
(Yoneda10_Param_Forget_0 : Yoneda10_data Yoneda01_Param_SubstF Yoneda01_Param_F)
(Heq_subst_0 : forall (G : obGenerator) (param : Yoneda00_Param_SubstF G), sval Yoneda10_Param_Forget' G param = sval Yoneda10_Param_Forget_0 G param)
(L : obGenerator)
(Yoneda10_Param_ll_ : Yoneda10_data (Yoneda01_Param_View (Parameter0 L)) Yoneda01_Param_SubstF),
 forall (G : obGenerator) (param : Yoneda00_Param_View (Parameter0 L) G),
  sval (Yoneda10_Param_PolyCoMod Yoneda10_Param_ll_ Yoneda10_Param_Forget) G param = sval (Yoneda10_Param_PolyCoMod Yoneda10_Param_ll_ Yoneda10_Param_Forget_0) G param.
Proof.
  intros; simpl; rewrite -Heq_subst_0 -Heq_subst; reflexivity.
Qed.

(* ----- param ----- *)
Lemma Yoneda10_PolyTransf_Param_default_morphism_Param_ee_morphism :
forall (Yoneda00_Param_F : obGenerator -> Type)
(Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
(Yoneda00_Param_E : obGenerator -> Type)
(Yoneda01_Param_E : Yoneda01_data Yoneda00_Param_E)
(Yoneda10_Param_ee : forall G : obGenerator, Yoneda00_Param_F G -> forall P : obParametrizator, is_Parameter0 G P -> Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_E)
(Yoneda10_Param_ee_morphism :
   forall (G : obGenerator) (param : Yoneda00_Param_F G) (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
         forall (param_ : Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_F )
           (Heq_param :  param = sval param_ G (is_Parameter0_transp_rev_codom is_Parameter0_P (@unitParametrizator (Parameter0 G)))),
forall (G' : obGenerator) (param' : Yoneda00_Param_View P G') (G'' : obGenerator) (param'' : Yoneda00_Param_View (Parameter0 G') G''),
sval (Yoneda10_Param_ee G param P is_Parameter0_P) G'' (param'' o>Parametrizator param') = sval (Yoneda10_Param_ee G' (sval param_ G' param') (Parameter0 G') (Is_Parameter0 G')) G'' param'')
(Yoneda00_Param_D : obGenerator -> Type)
(Yoneda01_Param_D : Yoneda01_data Yoneda00_Param_D)
(Yoneda10_Param_dd : Yoneda10_data Yoneda01_Param_E Yoneda01_Param_D),
forall (G : obGenerator) (param : Yoneda00_Param_F G) (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P) (param_ : Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_F),
  param = sval param_ G (is_Parameter0_transp_rev_codom is_Parameter0_P unitParametrizator) ->
  forall (G' : obGenerator) (param' : Yoneda00_Param_View P G') (G'' : obGenerator) (param'' : Yoneda00_Param_View (Parameter0 G') G''),
  sval (Yoneda10_Param_PolyCoMod (Yoneda10_Param_ee G param P is_Parameter0_P) Yoneda10_Param_dd) G'' (param'' o>Parametrizator param') = sval (Yoneda10_Param_PolyCoMod (Yoneda10_Param_ee G' (sval param_ G' param') (Parameter0 G') (Is_Parameter0 G')) Yoneda10_Param_dd) G'' param''.
Proof.
  intros; simpl. congr (sval Yoneda10_Param_dd _ ).
  exact: Yoneda10_Param_ee_morphism.
Qed.

Lemma Yoneda10_Param_morphism_Parameter1 :
  forall (Yoneda00_Param_F : obGenerator -> Type) (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
  (Yoneda10_Param_param_ : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F )
        (Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G),
            param = sval (Yoneda10_Param_param_ G param) G (@unitParametrizator (Parameter0 G)) )

       (Yoneda00_Param_E : obGenerator -> Type) (Yoneda01_Param_E : Yoneda01_data Yoneda00_Param_E)
    (Yoneda10_Param_ee : forall G : obGenerator, Yoneda00_Param_F G -> Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_E)
(Yoneda10_Param_ee_morphism : (**TODO: reverse equality ? *)
   forall G (param : Yoneda00_Param_F G),
   forall (param_ : Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F )
     (Heq_param :  param = sval param_ G (@unitParametrizator (Parameter0 G)) ),
   forall G'  (param' : Yoneda00_Param_View (Parameter0 G) G')
     G'' (param'' : Yoneda00_Param_View (Parameter0 G') G''),
     sval (Yoneda10_Param_ee G param) G'' (param'' o>Parametrizator param') =
     sval (Yoneda10_Param_ee G' (sval param_ G' param')) G'' param'')
    (G G' : obGenerator) (g : 'Generator( G' ~> G ))
         (param : Yoneda00_Param_F G) (G'' : obGenerator) (param' : Yoneda00_Param_View (Parameter0 G') G''),
    sval (Yoneda10_Param_ee G param) G'' (param' o>Parametrizator Parameter1 g) = sval (Yoneda10_Param_ee G' (g o>Generator_[sval Yoneda01_Param_F] param)) G'' param'.
Proof.
  intros.
  erewrite Yoneda10_Param_ee_morphism; last by exact: Heq_param.
    rewrite [Parameter1 g]unitParametrizator_polyParametrizator.
    rewrite -[in LHS](proj2_sig (Yoneda10_Param_param_ G param));
    rewrite -[in LHS]Heq_param; reflexivity.
Qed.
End Senses_convCoMod.

Reserved Notation "ff0 <~~ ff" (at level 70).
Reserved Notation "param_ff0 <~~_ param_ff" (at level 70).

Inductive convCoMod : forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
    (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E),
  forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
    (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F),
  forall Yoneda10_Param_ff Yoneda10_Form_ff (ff : 'CoMod( E ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff )),
  forall Yoneda10_Param_ff0 Yoneda10_Form_ff0 (ff0 : 'CoMod( E ~> F @_ Yoneda10_Param_ff0 @^ Yoneda10_Form_ff0 )), Prop :=

(**  ----- the total/(multi-step) conversions -----  **)
| convCoMod_Refl : forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
                     (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E),
    forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
      (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F),
    forall Yoneda10_Param_ff Yoneda10_Form_ff (ff : 'CoMod( E ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff )),

      ff <~~ ff

| convCoMod_Trans : forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
                        (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E),
    forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
      (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F),
    forall Yoneda10_Param_ff Yoneda10_Form_ff (ff : 'CoMod( E ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff )),
    forall Yoneda10_Param_uTrans Yoneda10_Form_uTrans (uTrans : 'CoMod( E ~> F @_ Yoneda10_Param_uTrans @^ Yoneda10_Form_uTrans )),
      uTrans <~~ ff ->
    forall Yoneda10_Param_ff0 Yoneda10_Form_ff0 (ff0 : 'CoMod( E ~> F @_ Yoneda10_Param_ff0 @^ Yoneda10_Form_ff0 )),
      ff0 <~~ uTrans -> ff0 <~~ ff

(**  ----- the congruences (recursive) conversions for morphisms -----  **)
| PolyCoMod_cong : forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
  (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F),

    forall Yoneda00_Form_F' Yoneda01_Form_F' Yoneda00_Param_F' Yoneda01_Param_F' Yoneda10_FormParam_F'
      (F' : @obCoMod Yoneda00_Form_F' Yoneda01_Form_F' Yoneda00_Param_F' Yoneda01_Param_F' Yoneda10_FormParam_F'),

    forall Yoneda10_Param_ff' Yoneda10_Form_ff'
      (ff' : 'CoMod( F' ~> F @_ Yoneda10_Param_ff' @^ Yoneda10_Form_ff' )),

      forall Yoneda00_Form_F'' Yoneda01_Form_F'' Yoneda00_Param_F'' Yoneda01_Param_F'' Yoneda10_FormParam_F''
        (F'' : @obCoMod Yoneda00_Form_F'' Yoneda01_Form_F'' Yoneda00_Param_F'' Yoneda01_Param_F'' Yoneda10_FormParam_F''),

      forall Yoneda10_Param_ff_ Yoneda10_Form_ff_
        (ff_ : 'CoMod( F'' ~> F' @_ Yoneda10_Param_ff_ @^ Yoneda10_Form_ff_ )),

      forall Yoneda10_Param_ff'0 Yoneda10_Form_ff'0
        (ff'0 : 'CoMod( F' ~> F @_ Yoneda10_Param_ff'0 @^ Yoneda10_Form_ff'0 )),

      forall Yoneda10_Param_ff_0 Yoneda10_Form_ff_0
        (ff_0 : 'CoMod( F'' ~> F' @_ Yoneda10_Param_ff_0 @^ Yoneda10_Form_ff_0 )),

        ff'0 <~~ ff' -> ff_0 <~~ ff_ ->
        ( ff_0 o>CoMod ff'0 ) <~~ ( ff_ o>CoMod ff' )

| ViewedFunctor1_default_cong :
    forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
      (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F)
      (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
      (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E)
      (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
    forall Yoneda10_Param_ff0 (param_ff : 'CoMod_( Param_E ~>  Param_F @_ Yoneda10_Param_ff0 ))
      Yoneda10_Param_ff Yoneda10_Form_ff (ff : 'CoMod( E ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff )) Heq_param,
    forall Yoneda10_Param_ff00 (param_ff0 : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff00 ))
      Yoneda10_Param_ff0 Yoneda10_Form_ff0 (ff0 : 'CoMod( E ~>  F @_ Yoneda10_Param_ff0 @^ Yoneda10_Form_ff0 )) Heq_param0,
      param_ff0 <~~_ param_ff ->  ff0 <~~ ff ->
      ( 'ViewedFunctor1 ff0 @_ Heq_param0 = param_ff0 ) <~~ ( 'ViewedFunctor1 ff @_ Heq_param = param_ff )

| UnitViewedFunctor_default_cong :
    forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
      (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F)
      (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
               (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E),
    forall Yoneda10_Param_ff,
    forall Yoneda10_Form_ff (ff : 'CoMod( E ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff )),
    forall Yoneda10_Param_ff0 ,
    forall Yoneda10_Form_ff0 (ff0 : 'CoMod( E ~> F @_ Yoneda10_Param_ff0 @^ Yoneda10_Form_ff0 )),
      ff0 <~~ ff ->
      ( ff0 o>CoMod 'UnitViewedFunctor @_ Param_F ) <~~ ( ff o>CoMod 'UnitViewedFunctor @_ Param_F )

| PolyElement_default_cong :
    forall Yoneda00_Form_F (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F) Yoneda00_Param_F (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)  (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F),
    forall (isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F)
      (isFiniteness_FormParam_F : Finiteness.isFiniteness_FormParam_ Yoneda10_FormParam_F),
    forall (Yoneda10_Param_param_ : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F )
      (Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          param = sval (Yoneda10_Param_param_ G param) G (@unitParametrizator (Parameter0 G)) )
      Yoneda10_Param_param_morphism,
    forall (Heq_param0 : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          param = sval (Yoneda10_Param_param_ G param) G (@unitParametrizator (Parameter0 G)) )
      Yoneda10_Param_param0_morphism,
    forall (G : obGenerator) (param : Yoneda00_Param_F G) (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
    forall (form0 : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
      sval form0 = sval form ->
      ( 'PolyElement form0 @_ isFiniteness_Param_F , Heq_param0 , Yoneda10_Param_param0_morphism @^ isFiniteness_FormParam_F)
      <~~ ( 'PolyElement form @_ isFiniteness_Param_F , Heq_param , Yoneda10_Param_param_morphism @^ isFiniteness_FormParam_F)

| PolyTransf_default_cong :
    forall Yoneda00_Form_F (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F) Yoneda00_Param_F (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)  (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F),
    forall (isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F)
      (isFiniteness_FormParam_F : Finiteness.isFiniteness_FormParam_ Yoneda10_FormParam_F),
    forall (Yoneda10_Param_param_ : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F )
        (Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G),
            param = sval (Yoneda10_Param_param_ G param) G (@unitParametrizator (Parameter0 G)) ),
    forall (Yoneda10_Param_param0_ : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F )
        (Heq_param0 : forall (G : obGenerator) (param : Yoneda00_Param_F G),
            param = sval (Yoneda10_Param_param0_ G param) G (@unitParametrizator (Parameter0 G)) ),

    forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
      (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E)
    (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),

    forall (Yoneda10_Param_ee0 : forall (G : obGenerator) (param : Yoneda00_Param_F G), _ )
      (param_ee0_ : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          'CoMod_( View_Param (Parameter0 G) ~> Param_E @_ (Yoneda10_Param_ee0 G param) )),

    forall (Yoneda10_Param_ee : forall (G : obGenerator) (param : Yoneda00_Param_F G) (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param), _ )
      (Yoneda10_Form_ee : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                            (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param), _)
      Heq_param_ee Yoneda10_Param_ee0_morphism Yoneda10_Form_ee_quotientLogical Yoneda10_Form_ee_morphism
      (ee_ : forall (G : obGenerator) (param : Yoneda00_Param_F G)
              (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
          'CoMod( View G ~> E @_ (Yoneda10_Param_ee G param form) @^ (Yoneda10_Form_ee G param form))),

    forall (Yoneda10_Param_ee00 : forall (G : obGenerator) (param : Yoneda00_Param_F G), _ )
      (param_ee00_ : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          'CoMod_( View_Param (Parameter0 G) ~> Param_E @_ (Yoneda10_Param_ee00 G param) )),

    forall (Yoneda10_Param_ee0 : forall (G : obGenerator) (param : Yoneda00_Param_F G)(form : Yoneda00_AtParam_ Yoneda10_FormParam_F param), _ )
      (Yoneda10_Form_ee0 : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                            (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param), _)
      Heq_param_ee0 Yoneda10_Param_ee00_morphism
      Yoneda10_Form_ee0_quotientLogical Yoneda10_Form_ee0_morphism
      (ee0_ : forall (G : obGenerator) (param : Yoneda00_Param_F G)
              (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
          'CoMod( View G ~> E @_ (Yoneda10_Param_ee0 G param form) @^ (Yoneda10_Form_ee0 G param form))),

      ( param_ee00_( _ )(Finiteness.param1 isFiniteness_Param_F )
          <~~_ param_ee0_( _ )(Finiteness.param1 isFiniteness_Param_F) ) ->

      ( param_ee00_( _ )(Finiteness.param2 isFiniteness_Param_F )
          <~~_ param_ee0_( _ )(Finiteness.param2 isFiniteness_Param_F) ) ->

      ( ee0_( _ )( _ )(Finiteness.form1 isFiniteness_FormParam_F (Finiteness.param1 isFiniteness_Param_F ))
          <~~ ee_( _ )( _ )(Finiteness.form1 isFiniteness_FormParam_F (Finiteness.param1 isFiniteness_Param_F)) ) ->

      ( ee0_( _ )( _ )(Finiteness.form2 isFiniteness_FormParam_F (Finiteness.param1 isFiniteness_Param_F))
          <~~ ee_( _ )( _ )(Finiteness.form2 isFiniteness_FormParam_F (Finiteness.param1 isFiniteness_Param_F)) ) ->

      ( ee0_( _ )( _ )(Finiteness.form1 isFiniteness_FormParam_F (Finiteness.param2 isFiniteness_Param_F))
          <~~ ee_( _ )( _ )(Finiteness.form1 isFiniteness_FormParam_F (Finiteness.param2 isFiniteness_Param_F)) ) ->

      ( ee0_( _ )( _ )(Finiteness.form2 isFiniteness_FormParam_F (Finiteness.param2 isFiniteness_Param_F))
          <~~ ee_( _ )( _ )(Finiteness.form2 isFiniteness_FormParam_F (Finiteness.param2 isFiniteness_Param_F)) ) ->

      [[ ee0_ @_  param_ee00_ , isFiniteness_Param_F , Heq_param0 , Heq_param_ee0 , Yoneda10_Param_ee00_morphism @^ isFiniteness_FormParam_F , Yoneda10_Form_ee0_quotientLogical , Yoneda10_Form_ee0_morphism ]]
      <~~ [[ ee_ @_  param_ee0_ , isFiniteness_Param_F , Heq_param , Heq_param_ee, Yoneda10_Param_ee0_morphism @^ isFiniteness_FormParam_F , Yoneda10_Form_ee_quotientLogical , Yoneda10_Form_ee_morphism ]]

| Forget_cong :
    forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
      (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F)
      (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda00_Param_SubstF Yoneda01_Param_SubstF
      (Param_SubstF : @obCoMod_Param Yoneda00_Param_SubstF Yoneda01_Param_SubstF),
    forall (Yoneda10_Param_Forget : Yoneda10_data Yoneda01_Param_SubstF Yoneda01_Param_F)
      (param_Forget : 'CoMod_( Param_SubstF ~> Param_F @_ Yoneda10_Param_Forget )),
    forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
      (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E),
    forall Yoneda10_Param_ee Yoneda10_Form_ee
      (ee : 'CoMod( F  ~> E @_ Yoneda10_Param_ee @^ Yoneda10_Form_ee )),
    forall Yoneda10_Param_Forget'
      (Heq_subst : forall G param, sval Yoneda10_Param_Forget' G param = sval Yoneda10_Param_Forget G param),
    forall Yoneda10_Param_Forget_0
      (param_Forget_0 : 'CoMod_( Param_SubstF ~> Param_F @_ Yoneda10_Param_Forget_0 )),
    forall Yoneda10_Param_ee_0 Yoneda10_Form_ee_0
      (ee0 : 'CoMod( F ~> E @_ Yoneda10_Param_ee_0 @^ Yoneda10_Form_ee_0 )),
    forall (Heq_subst_0 : forall G param, sval Yoneda10_Param_Forget' G param = sval Yoneda10_Param_Forget_0 G param),

      param_Forget_0 <~~_ param_Forget -> ee0 <~~ ee ->
      ( 'Forget @_ Heq_subst_0 = param_Forget_0 o>CoMod ee0 )
        <~~ ( 'Forget @_ Heq_subst = param_Forget o>CoMod ee )

| Remember_cong :  forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
   (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F)
   (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
 forall Yoneda00_Param_SubstF Yoneda01_Param_SubstF
   (Param_SubstF : @obCoMod_Param Yoneda00_Param_SubstF Yoneda01_Param_SubstF),
 forall Yoneda10_Param_Forget (param_Forget : 'CoMod_( Param_SubstF ~> Param_F @_ Yoneda10_Param_Forget )),
 forall (L : obGenerator) Yoneda10_Param_ll Yoneda10_Form_ll
   (ll : 'CoMod( View L ~> F @_ Yoneda10_Param_ll @^ Yoneda10_Form_ll )),
 forall (**MEMO: when the generating parametrizator-functor is full then
      this polyelement [Yoneda10_Param_ll_] is the same as one (decidable) single element [param : Yoneda01_Param_SubstF (Parameter0 L)] *)
   (Yoneda10_Param_ll_ : Yoneda10_data (Yoneda01_Param_View (Parameter0 L)) Yoneda01_Param_SubstF)
   (Heq_param : forall G param, sval Yoneda10_Param_ll G param
                           = sval (Yoneda10_Param_PolyCoMod Yoneda10_Param_ll_ Yoneda10_Param_Forget) G param),
 forall (Yoneda10_Param_Forget' : Yoneda10_data Yoneda01_Param_SubstF Yoneda01_Param_F)
   (Heq_subst : forall G param, sval Yoneda10_Param_Forget' G param = sval Yoneda10_Param_Forget G param),

    (*TODO: more or less general ?   *)
    forall Yoneda10_Param_Forget_0 (param_Forget_0 : 'CoMod_( Param_SubstF ~> Param_F @_ Yoneda10_Param_Forget_0 )),
    forall Yoneda10_Param_ll0 Yoneda10_Form_ll0 (ll0 : 'CoMod( View L ~> F  @_ Yoneda10_Param_ll0 @^ Yoneda10_Form_ll0 )),
    forall (Yoneda10_Param_ll0_ : Yoneda10_data (Yoneda01_Param_View (Parameter0 L)) Yoneda01_Param_SubstF)
        (Heq_param0 : forall G param, sval Yoneda10_Param_ll0 G param
                                = sval (Yoneda10_Param_PolyCoMod Yoneda10_Param_ll0_ Yoneda10_Param_Forget_0) G param),
    forall (Heq_subst_0 : forall G param, sval Yoneda10_Param_Forget' G param = sval Yoneda10_Param_Forget_0 G param),

    forall (Heq_param1 : (**MEMO: when the generating parametrizator-functor is full then
      this polyelement [Yoneda10_Param_ll_] is the same as one (decidable) single element [param : Yoneda01_Param_SubstF (Parameter0 L)] *)
         forall G param, sval Yoneda10_Param_ll0_ G param = sval Yoneda10_Param_ll_ G param ),
      param_Forget_0 <~~_ param_Forget -> ll0 <~~ ll ->
      ( << ll0 @_ Heq_param0 = Yoneda10_Param_ll0_ , Heq_subst_0 = param_Forget_0 >> )
        <~~ ( << ll @_ Heq_param = Yoneda10_Param_ll_ , Heq_subst = param_Forget >> )

(** ----- the constant conversions which are used during the polymorphism elimination ----- **)

| PolyCoMod'UnitCoMod :
    forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
    (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E),

    forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
    (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F),
  forall Yoneda10_Param_ff Yoneda10_Form_ff (ff : 'CoMod( E ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff )),

    ff <~~ ( ff o>CoMod (@'UnitCoMod F) )

(**MEMO: not all cases of this conversion are necessary , when the postfix is [UnitCoMod] , [UnitViewedFunctor_default] **)
| PolyCoMod_UnitCoMod :
    forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
    (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E),
  forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
    (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F),
  forall Yoneda10_Param_ff Yoneda10_Form_ff (ff : 'CoMod( E ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff )),

    ff <~~ ( 'UnitCoMod o>CoMod ff )

(** a.k.a View1_View1 **)
| View1_morphism :  forall (G H : obGenerator) (g : 'Generator( H ~> G )), forall (H' : obGenerator) (h : 'Generator( H' ~> H )),
    ('View1 (h o>Generator g))  <~~  ('View1 h o>CoMod 'View1 g )

(** a.k.a ViewedFunctor1_default_ViewedFunctor1_default  **)
| ViewedFunctor1_default_morphism :
    forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
      (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F)
      (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
      (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E)
      (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
    forall Yoneda10_Param_ff0 (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff0 ))
      Yoneda10_Param_ff Yoneda10_Form_ff (ff : 'CoMod( E ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff )) Heq_param,
    forall Yoneda00_Form_D Yoneda01_Form_D Yoneda00_Param_D Yoneda01_Param_D Yoneda10_FormParam_D
      (D : @obCoMod Yoneda00_Form_D Yoneda01_Form_D Yoneda00_Param_D Yoneda01_Param_D Yoneda10_FormParam_D)
      (Param_D : @obCoMod_Param Yoneda00_Param_D Yoneda01_Param_D),
    forall Yoneda10_Param_dd0 (param_dd : 'CoMod_( Param_F ~> Param_D @_ Yoneda10_Param_dd0 ))
      Yoneda10_Param_dd Yoneda10_Form_dd (dd : 'CoMod( F  ~> D @_ Yoneda10_Param_dd @^ Yoneda10_Form_dd )) Heq_param_dd ,

      ( 'ViewedFunctor1 (ff o>CoMod dd ) @_ (Yoneda10_ViewedFunctor1_default_morphism Heq_param Heq_param_dd) = (param_ff o>CoMod_ param_dd ))
        <~~ ( 'ViewedFunctor1 ff @_ Heq_param = param_ff ) o>CoMod ( 'ViewedFunctor1 dd @_ Heq_param_dd = param_dd )

(** a.k.a ViewedFunctor1_default_UnitViewedFunctor_default **)
| UnitViewedFunctor_default_morphismPost :
    forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
      (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F)
      (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
               (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E),
    forall Yoneda10_Param_ff,
    forall Yoneda10_Form_ff (ff : 'CoMod( E ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff )),
    forall Yoneda00_Form_D Yoneda01_Form_D Yoneda00_Param_D Yoneda01_Param_D Yoneda10_FormParam_D
      (D : @obCoMod Yoneda00_Form_D Yoneda01_Form_D Yoneda00_Param_D Yoneda01_Param_D Yoneda10_FormParam_D)
      (Param_D : @obCoMod_Param Yoneda00_Param_D Yoneda01_Param_D),
    forall Yoneda10_Param_dd0 (param_dd : 'CoMod_(  Param_F ~> Param_D @_ Yoneda10_Param_dd0 )),
    forall Yoneda10_Param_dd Yoneda10_Form_dd (dd : 'CoMod( F ~> D @_ Yoneda10_Param_dd @^ Yoneda10_Form_dd )) Heq_param,

      ( ( ff o>CoMod dd ) o>CoMod 'UnitViewedFunctor @_ Param_D )
        <~~ ( ( ff o>CoMod 'UnitViewedFunctor @_ Param_F ) o>CoMod ( 'ViewedFunctor1 dd @_ Heq_param = param_dd ) )

(** a.k.a ViewedFunctor1_default_PolyTransf_default **)
| PolyTransf_default_morphism :
    forall Yoneda00_Form_F (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F) Yoneda00_Param_F (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)  (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F),
    forall (isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F)
      (isFiniteness_FormParam_F : Finiteness.isFiniteness_FormParam_ Yoneda10_FormParam_F),
    forall (Yoneda10_Param_param_ : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F )
        (Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G),
            param = sval (Yoneda10_Param_param_ G param) G (@unitParametrizator (Parameter0 G)) ),

    forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
      (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E)
      (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),

    forall (Yoneda10_Param_ee0 : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_E)
      (param_ee0_ : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          'CoMod_( View_Param (Parameter0 G) ~> Param_E @_ (Yoneda10_Param_ee0 G param) )),

    forall  (Yoneda10_Param_ee : forall (G : obGenerator) (param : Yoneda00_Param_F G)(form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
          Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_E)
     (Yoneda10_Form_ee : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                            (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param), _)
      Heq_param_ee Yoneda10_Param_ee0_morphism  Yoneda10_Form_ee_quotientLogical Yoneda10_Form_ee_morphism
      (ee_ : forall (G : obGenerator) (param : Yoneda00_Param_F G)
              (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
          'CoMod( View G ~> E @_ (Yoneda10_Param_ee G param form) @^ (Yoneda10_Form_ee G param form))),

    forall Yoneda00_Form_D Yoneda01_Form_D Yoneda00_Param_D Yoneda01_Param_D Yoneda10_FormParam_D
      (D : @obCoMod Yoneda00_Form_D Yoneda01_Form_D Yoneda00_Param_D Yoneda01_Param_D Yoneda10_FormParam_D)
      (Param_D : @obCoMod_Param Yoneda00_Param_D Yoneda01_Param_D),
    forall Yoneda10_Param_dd0 (param_dd : 'CoMod_( Param_E ~> Param_D @_ Yoneda10_Param_dd0 )),
    forall Yoneda10_Param_dd Yoneda10_Form_dd
      (dd : 'CoMod( E ~> D @_ Yoneda10_Param_dd @^ Yoneda10_Form_dd ))  Heq_param_dd,

      ( [[ (fun G param form => ee_(G)(param)(form) o>CoMod dd)
             @_ (fun G param => param_ee0_(G)(param) o>CoMod_ param_dd) , isFiniteness_Param_F , Heq_param ,
           (Yoneda10_PolyTransf_default_morphism_Heq_param_ee Heq_param_ee Heq_param_dd)
           , (Yoneda10_PolyTransf_default_morphism_Param_ee0_morphism Yoneda10_Param_ee0_morphism Yoneda10_Param_dd0)
               @^ isFiniteness_FormParam_F , (Yoneda10_PolyTransf_default_morphism_Form_ee_quotientLogical Yoneda10_Form_ee_quotientLogical Yoneda10_Form_dd)
           , (Yoneda10_PolyTransf_default_morphism_Form_ee_morphism Yoneda10_Form_ee_morphism Yoneda10_Form_dd) ]] )
        <~~ ( [[ ee_ @_ param_ee0_ , isFiniteness_Param_F , Heq_param , Heq_param_ee , Yoneda10_Param_ee0_morphism @^ isFiniteness_FormParam_F , Yoneda10_Form_ee_quotientLogical , Yoneda10_Form_ee_morphism ]]
              o>CoMod ( 'ViewedFunctor1 dd @_ Heq_param_dd = param_dd ) )

(** a.k.a UnitViewedFunctor_default_PolyCoMod **)
| UnitViewedFunctor_default_morphismPre :
    forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
      (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F)
      (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
      (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E),
    forall Yoneda10_Param_ff Yoneda10_Form_ff (ff : 'CoMod( E ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff )),
    forall Yoneda00_Form_D Yoneda01_Form_D Yoneda00_Param_D Yoneda01_Param_D Yoneda10_FormParam_D
      (D : @obCoMod Yoneda00_Form_D Yoneda01_Form_D Yoneda00_Param_D Yoneda01_Param_D Yoneda10_FormParam_D),
    forall Yoneda10_Param_dd Yoneda10_Form_dd (dd : 'CoMod( D ~> E @_ Yoneda10_Param_dd @^ Yoneda10_Form_dd )),

      ( ( dd o>CoMod ff ) o>CoMod 'UnitViewedFunctor @_ Param_F)
        <~~ ( dd o>CoMod ( ff o>CoMod 'UnitViewedFunctor @_ Param_F) )

(** a.k.a PolyElement_default_View1 **)
| PolyElement_default_morphism :
    forall Yoneda00_Form_F (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F) Yoneda00_Param_F (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)  (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F),
    forall (isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F)
      (isFiniteness_FormParam_F : Finiteness.isFiniteness_FormParam_ Yoneda10_FormParam_F),
    forall (Yoneda10_Param_param_ : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F )
      (Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          param = sval (Yoneda10_Param_param_ G param) G (@unitParametrizator (Parameter0 G)) )
    Yoneda10_Param_param_morphism,
    forall (G : obGenerator) param (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
    forall (H : obGenerator) (g : 'Generator( H ~> G )),

      ( 'PolyElement ( g o>GeneratorAtParam_[sval (Yoneda01_AtParam_ Yoneda10_FormParam_F)] form )
                     @_ isFiniteness_Param_F , Heq_param , Yoneda10_Param_param_morphism @^ isFiniteness_FormParam_F )
       <~~ ( ( 'View1 g o>CoMod 'PolyElement form @_ isFiniteness_Param_F , Heq_param , Yoneda10_Param_param_morphism  @^ isFiniteness_FormParam_F )  )

| PolyTransf_default_PolyElement_default :
    forall Yoneda00_Form_F (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F) Yoneda00_Param_F (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)  (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F),
    forall (isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F)
      (isFiniteness_FormParam_F : Finiteness.isFiniteness_FormParam_ Yoneda10_FormParam_F),
    forall (Yoneda10_Param_param_ : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F )
        (Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G),
            param = sval (Yoneda10_Param_param_ G param) G (@unitParametrizator (Parameter0 G)) ),

    forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
      (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E)
      (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),

    forall (Yoneda10_Param_ee0 : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_E)
      (param_ee0_ : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          'CoMod_( View_Param (Parameter0 G) ~> Param_E @_ (Yoneda10_Param_ee0 G param) )),
    forall (Yoneda10_Param_ee : forall (G : obGenerator) (param : Yoneda00_Param_F G) (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
          Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_E)
      (Yoneda10_Form_ee : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                            (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
          Yoneda10_Form_data (Yoneda10_FormParam_View G) Yoneda10_FormParam_E (Yoneda10_Param_ee G param form))
      Heq_param_ee Yoneda10_Param_ee0_morphism Yoneda10_Form_ee_quotientLogical
      (Yoneda10_Form_ee_morphism :
         forall (G G' : obGenerator) (g : 'Generator( G' ~> G )) (param : Yoneda00_Param_F G)
           (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
         forall (G'' : obGenerator) (param' : (Yoneda00_Param_View (Parameter0 G')) G'')
           (form' : Yoneda00_AtParam_ (Yoneda10_FormParam_View G') param'),
           sval (sval (Yoneda10_Form_ee G param form)
                      G'' (param' o>Parametrizator (Parameter1 g))
                      (form' o>GeneratorAtParam g))
           = sval (sval (Yoneda10_Form_ee G' (g o>Generator_[sval Yoneda01_Param_F] param)
                                          (g o>GeneratorAtParam_[sval (Yoneda01_AtParam_(Yoneda10_FormParam_F))] form))
                        G'' param' form'))
      (ee_ : forall (G : obGenerator) (param : Yoneda00_Param_F G)
              (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
          'CoMod( View G ~> E @_ (Yoneda10_Param_ee G param form) @^ (Yoneda10_Form_ee G param form))),
    forall (Yoneda10_Param_param0_ : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F )
        (Heq_param0 : forall (G : obGenerator) (param : Yoneda00_Param_F G),
            param = sval (Yoneda10_Param_param0_ G param) G (@unitParametrizator (Parameter0 G)) )
        Yoneda10_Param_param0_morphism,
    forall (G : obGenerator) param (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),

      ( ( ee_(G)(param)(form) ) o>CoMod 'UnitViewedFunctor @_ Param_E )
        <~~ ( ( 'PolyElement form @_ isFiniteness_Param_F , Heq_param0 , Yoneda10_Param_param0_morphism @^ isFiniteness_FormParam_F )
                o>CoMod [[ ee_ @_  param_ee0_ , isFiniteness_Param_F , Heq_param , Heq_param_ee , Yoneda10_Param_ee0_morphism @^ isFiniteness_FormParam_F , Yoneda10_Form_ee_quotientLogical , Yoneda10_Form_ee_morphism ]]  )

| Remember_morphism :
 forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
   (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F)
   (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
 forall Yoneda00_Param_SubstF Yoneda01_Param_SubstF
   (Param_SubstF : @obCoMod_Param Yoneda00_Param_SubstF Yoneda01_Param_SubstF),
 forall Yoneda10_Param_Forget (param_Forget : 'CoMod_( Param_SubstF ~> Param_F @_ Yoneda10_Param_Forget )),
 forall (L : obGenerator) Yoneda10_Param_ll Yoneda10_Form_ll
   (ll : 'CoMod( View L ~> F @_ Yoneda10_Param_ll @^ Yoneda10_Form_ll )),
 forall (Yoneda10_Param_ll_ : Yoneda10_data (Yoneda01_Param_View (Parameter0 L)) Yoneda01_Param_SubstF)
   (Heq_param : forall G param, sval Yoneda10_Param_ll G param
                           = sval (Yoneda10_Param_PolyCoMod Yoneda10_Param_ll_ Yoneda10_Param_Forget) G param),
 forall (Yoneda10_Param_Forget' : Yoneda10_data Yoneda01_Param_SubstF Yoneda01_Param_F)
   (Heq_subst : forall G param, sval Yoneda10_Param_Forget' G param = sval Yoneda10_Param_Forget G param),

 forall (D : obGenerator) (d : 'Generator( D ~> L )),

   ( << ( ( 'View1 d ) o>CoMod ll )  @_ (Yoneda10_Remember_morphism Heq_param d)
     = (Yoneda10_Param_PolyCoMod (Yoneda10_Param_View1 (Parameter1 d)) Yoneda10_Param_ll_) , Heq_subst = param_Forget >> )
     <~~ ( ( 'View1 d ) o>CoMod ( << ll @_ Heq_param = Yoneda10_Param_ll_ , Heq_subst = param_Forget >> ) )

| Forget_morphism :
    forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
      (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F)
      (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda00_Param_SubstF Yoneda01_Param_SubstF
      (Param_SubstF : @obCoMod_Param Yoneda00_Param_SubstF Yoneda01_Param_SubstF),
    forall Yoneda10_Param_Forget
      (param_Forget : 'CoMod_( Param_SubstF ~> Param_F @_ Yoneda10_Param_Forget )),
    forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
      (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E),
    forall Yoneda10_Param_ee Yoneda10_Form_ee,
    forall (ee : 'CoMod( F ~> E @_ Yoneda10_Param_ee @^ Yoneda10_Form_ee )),
    forall Yoneda10_Param_Forget'
      (Heq_subst : forall G param, sval Yoneda10_Param_Forget' G param = sval Yoneda10_Param_Forget G param),

    forall Yoneda00_Form_D Yoneda01_Form_D Yoneda00_Param_D Yoneda01_Param_D Yoneda10_FormParam_D
      (D : @obCoMod Yoneda00_Form_D Yoneda01_Form_D Yoneda00_Param_D Yoneda01_Param_D Yoneda10_FormParam_D),
    forall Yoneda10_Param_dd Yoneda10_Form_dd (dd : 'CoMod( E ~> D @_ Yoneda10_Param_dd @^ Yoneda10_Form_dd )),

      ( 'Forget @_ Heq_subst = param_Forget o>CoMod ( ee o>CoMod dd ) )
        <~~ ( 'Forget @_ Heq_subst = param_Forget o>CoMod ee ) o>CoMod dd

| Remember_Forget :
 forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
   (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F)
   (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
 forall Yoneda00_Param_SubstF Yoneda01_Param_SubstF
   (Param_SubstF : @obCoMod_Param Yoneda00_Param_SubstF Yoneda01_Param_SubstF),
 forall Yoneda10_Param_Forget  (param_Forget : 'CoMod_( Param_SubstF ~> Param_F @_ Yoneda10_Param_Forget )),
 forall Yoneda10_Param_Forget' (Heq_subst : forall G param, sval Yoneda10_Param_Forget' G param = sval Yoneda10_Param_Forget G param),
 forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
   (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E),
 forall Yoneda10_Param_ee Yoneda10_Form_ee
   (ee : 'CoMod( F ~> E @_ Yoneda10_Param_ee @^ Yoneda10_Form_ee )),

 forall Yoneda10_Param_Forget_0 (param_Forget_0 : 'CoMod_( Param_SubstF ~> Param_F @_ Yoneda10_Param_Forget_0 )),
 forall (L : obGenerator) Yoneda10_Param_ll Yoneda10_Form_ll
   (ll : 'CoMod( View L ~> F @_ Yoneda10_Param_ll @^ Yoneda10_Form_ll )),
 forall (Yoneda10_Param_ll_ : Yoneda10_data (Yoneda01_Param_View (Parameter0 L)) Yoneda01_Param_SubstF)
   (Heq_param : forall G param, sval Yoneda10_Param_ll G param
                           = sval (Yoneda10_Param_PolyCoMod Yoneda10_Param_ll_ Yoneda10_Param_Forget_0) G param),
 forall (Heq_subst_0 : forall G param, sval Yoneda10_Param_Forget' G param = sval Yoneda10_Param_Forget_0 G param),

   ( ll o>CoMod ee )
     <~~ ( ( << ll @_ Heq_param = Yoneda10_Param_ll_ , Heq_subst_0 = param_Forget_0 >>
           : 'CoMod ( View L ~> _ @_ _ @^ _ ) )
           o>CoMod ( ( 'Forget @_ Heq_subst = param_Forget o>CoMod ee )
                     : 'CoMod ( Subst F Param_F Param_SubstF Yoneda10_Param_Forget' ~> E @_ _ @^ _ ) ) )

(** ----- the constant conversions which are only for the wanted sense of
substitution-object grammar ----- **)

| PolyTransf_default'PolyElement_default :
    forall Yoneda00_Form_F (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F) Yoneda00_Param_F (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)  (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F),
    forall (isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F)
      (isFiniteness_FormParam_F : Finiteness.isFiniteness_FormParam_ Yoneda10_FormParam_F),
    forall (Yoneda10_Param_param_ : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F )
      (Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          param = sval (Yoneda10_Param_param_ G param) G (@unitParametrizator (Parameter0 G)) )
      Yoneda10_Param_param_morphism,

    forall (Yoneda10_Param_param0_ : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                                 (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_F )
      (Heq_param0 : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                     (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          param = sval (Yoneda10_Param_param0_ G param P is_Parameter0_P)
                       G (is_Parameter0_transp_rev_codom is_Parameter0_P (@unitParametrizator (Parameter0 G))) )
      Yoneda10_Param_param0_morphism ,

    forall (Yoneda10_Param_param1_ : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F )
       (Heq_param1 : forall (G : obGenerator) (param : Yoneda00_Param_F G),
           param = sval (Yoneda10_Param_param1_ G param) G (@unitParametrizator (Parameter0 G)) )
       (Yoneda10_Param_ee0 : (forall (G : obGenerator) (param : Yoneda00_Param_F G),
                                Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F)
       := fun G param => Yoneda10_Param_param0_ G param (Parameter0 G) (Is_Parameter0 G) )
      (Yoneda10_Param_ee : (forall (G : obGenerator) (param : Yoneda00_Param_F G)
                             (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
                               Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F)
       := fun G param form => Yoneda10_Param_param_ G param )
      (Heq_param_ee : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                        (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
          forall G' param', sval (Yoneda10_Param_ee G param form) G' param' = sval (Yoneda10_Param_ee0 G param) G' param')
      Yoneda10_Param_ee0_morphism,

      (**TODO: PROBLEM ? SOLVED BY [PolyTransf_default_cong] ! also refer to [PolyTransf_Param_default'PolyElement_Param_default] below .
         how to finitely-recognize grammatically such many/function/parametrization of terms , where each member term is headed by ( the same ) constructor ( here [PolyElement_default] ) ?
         hmm using Finiteness for viewing-data , then could "extend" ( bad idea ... hmm not really , bad wording ) from knowing ( good wording ) finite-support of function/parametrization to "knowing" ( bad wording ) all of the function/parametrization ? Instead , [PolyTransf_default_cong] says that : for conversion , only the finite-support matters , therefore it shall be sufficient to do the tests inside the finite-support only ? if such test is succesful , then the redex is convertible to something fabricated whose outside-of-the-finite-support terms are defined using the same found head-constructor inside-of-the-finite-support *)
      ( ( @'UnitCoMod (ViewingFunctor_default isFiniteness_Param_F isFiniteness_FormParam_F) ) o>CoMod 'UnitViewedFunctor @_ (ViewingFunctor_Param_default isFiniteness_Param_F) )
        <~~  ( [[ (fun (G : obGenerator) (param : Yoneda00_Param_F G) (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param)
                 => 'PolyElement form  @_  isFiniteness_Param_F , Heq_param , Yoneda10_Param_param_morphism @^  isFiniteness_FormParam_F)
                  @_ (fun (G : obGenerator) (param : Yoneda00_Param_F G)
                      => 'PolyElement_ param  @_ isFiniteness_Param_F , (Is_Parameter0 G) ,  Heq_param0 , Yoneda10_Param_param0_morphism)
                , isFiniteness_Param_F , Heq_param1 , Heq_param_ee , Yoneda10_Param_ee0_morphism
                                                @^ isFiniteness_FormParam_F , (Yoneda10_PolyTransf_default'PolyElement_default Heq_param)
                , (Yoneda10_Form_PolyElement_default_morphism Heq_param) ]]  )

(** ----- the constant conversions which are only for the confluence lemma (TODO:) ----- **)

(**MEMO: absent ; none such confluence anymore :  << ( 'Forget o>CoMod ll ) >> <~~ ( 'Forget o>CoMod << ll >> )
| Forget'Remember : *)

(** ----- the constant conversions which may be assumed or are derivable by using the finished cut-elimination lemma
 ----- TODO: COMMENT ALL THIS SECTION----- **)

(**MEMO : extentionality ; memo the presence of the cut ;
   TODO: is this conversion derivable after the cut-elimination lemma ? *)
| Remember'Forget :
    forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
      (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F)
      (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda00_Param_SubstF Yoneda01_Param_SubstF
      (Param_SubstF : @obCoMod_Param Yoneda00_Param_SubstF Yoneda01_Param_SubstF),
    forall Yoneda10_Param_Forget (param_Forget : 'CoMod_( Param_SubstF ~> Param_F @_ Yoneda10_Param_Forget )),
    forall Yoneda10_Param_Forget' (Heq_subst : forall G param, sval Yoneda10_Param_Forget' G param = sval Yoneda10_Param_Forget G param),

    forall Yoneda10_Param_Forget_0 (param_Forget_0 : 'CoMod_( Param_SubstF ~> Param_F @_ Yoneda10_Param_Forget_0 )),
    forall (Heq_subst_0 : forall G param, sval Yoneda10_Param_Forget' G param = sval Yoneda10_Param_Forget_0 G param),
    forall (L : obGenerator) (Yoneda10_Param_ll_ : Yoneda10_data (Yoneda01_Param_View (Parameter0 L)) Yoneda01_Param_SubstF)
      Yoneda10_Form_ll_
      (ll_ : 'CoMod( View L ~> Subst F Param_F Param_SubstF Yoneda10_Param_Forget' @_ Yoneda10_Param_ll_ @^ Yoneda10_Form_ll_ )),

      ( ll_ )  <~~  ( << (ll_ o>CoMod ( 'Forget @_ Heq_subst = param_Forget o>CoMod (@'UnitCoMod F) ))
                       @_  (Yoneda10_Remember'Forget Heq_subst Heq_subst_0 Yoneda10_Param_ll_)
                    = Yoneda10_Param_ll_ , Heq_subst_0 =  param_Forget_0 >> )

where "ff0 <~~ ff" := (@convCoMod _ _ _ _ _ _ _ _ _ _ _ _ _ _ ff _ _ ff0)
with convCoMod_Param : forall Yoneda00_Param_E Yoneda01_Param_E (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
    forall Yoneda00_Param_F Yoneda01_Param_F (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda10_Param_ff (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff )),
    forall Yoneda10_Param_ff0 (param_ff0 : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff0 )), Prop :=

(**  ----- the total/(multi-step) conversions -----  **)
| convCoMod_Param_Refl : forall Yoneda00_Param_E Yoneda01_Param_E (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
    forall Yoneda00_Param_F Yoneda01_Param_F (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda10_Param_ff (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff )),
      param_ff <~~_ param_ff

| convCoMod_Param_Trans : forall Yoneda00_Param_E Yoneda01_Param_E (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
    forall Yoneda00_Param_F Yoneda01_Param_F (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda10_Param_ff (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff )),
    forall Yoneda10_Param_uTrans (uTrans : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_uTrans )),
      uTrans <~~_ param_ff ->
    forall Yoneda10_Param_ff0 (param_ff0 : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff0 )),
      param_ff0 <~~_ uTrans -> param_ff0 <~~_ param_ff

(**  ----- the congruences (recursive) conversions for morphisms -----  **)
| PolyCoMod_Param_cong : forall Yoneda00_Param_F Yoneda01_Param_F (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F)
  Yoneda00_Param_F' Yoneda01_Param_F' (Param_F' : @obCoMod_Param Yoneda00_Param_F' Yoneda01_Param_F')
  Yoneda10_Param_ff'  (param_ff' : 'CoMod_( Param_F' ~> Param_F @_ Yoneda10_Param_ff')),
  forall Yoneda00_Param_F'' Yoneda01_Param_F'' (Param_F'' : @obCoMod_Param Yoneda00_Param_F'' Yoneda01_Param_F''),
  forall Yoneda10_Param_ff_ (param_ff_ : 'CoMod_( Param_F'' ~> Param_F' @_ Yoneda10_Param_ff_ )),
  forall Yoneda10_Param_ff'0  (param_ff'0 : 'CoMod_( Param_F' ~> Param_F @_ Yoneda10_Param_ff'0)),
  forall Yoneda10_Param_ff_0 (param_ff_0 : 'CoMod_( Param_F'' ~> Param_F' @_ Yoneda10_Param_ff_0 )),
    param_ff'0 <~~_ param_ff' -> param_ff_0 <~~_ param_ff_ ->
    ( param_ff_0 o>CoMod_ param_ff'0 )
      <~~_ ( param_ff_ o>CoMod_ param_ff' )

| ViewedFunctor1_Param_default_cong : forall Yoneda00_Param_F Yoneda01_Param_F
                                   (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda00_Param_E Yoneda01_Param_E
      (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
    forall Yoneda10_Param_ff (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff )),
    forall Yoneda10_Param_ff0 (param_ff0 : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff0 )),
      param_ff0 <~~_ param_ff ->
      ( 'ViewedFunctor1_ param_ff0 ) <~~_ ( 'ViewedFunctor1_ param_ff )

| UnitViewedFunctor_Param_default_cong : forall Yoneda00_Param_F Yoneda01_Param_F
                                      (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda00_Param_E Yoneda01_Param_E
      (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
    forall Yoneda10_Param_ff (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff )),
    forall Yoneda10_Param_ff0 (param_ff0 : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff0 )),
      param_ff0 <~~_ param_ff ->
      ( param_ff0 o>CoMod_ 'UnitViewedFunctor_ ) <~~_ ( param_ff o>CoMod_ 'UnitViewedFunctor_ )

| PolyElement_Param_default_cong :
    forall Yoneda00_Param_F Yoneda01_Param_F,
    forall (isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F),
    forall (Yoneda10_Param_param_ : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                                 (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_F )
      (Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                     (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          param = sval (Yoneda10_Param_param_ G param P is_Parameter0_P)
                       G (is_Parameter0_transp_rev_codom is_Parameter0_P (@unitParametrizator (Parameter0 G))) )
      Yoneda10_Param_param_morphism,
    forall (Yoneda10_Param_param0_ : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                                 (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_F )
      (Heq_param0 : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                     (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          param = sval (Yoneda10_Param_param0_ G param P is_Parameter0_P)
                       G (is_Parameter0_transp_rev_codom is_Parameter0_P (@unitParametrizator (Parameter0 G))) )
      Yoneda10_Param_param0_morphism,

      (forall (G : obGenerator) (param : Yoneda00_Param_F G) (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          forall G', sval (Yoneda10_Param_param0_ G param P is_Parameter0_P) G'
                =1 sval (Yoneda10_Param_param_ G param P is_Parameter0_P) G') ->

      forall (G : obGenerator) (param : Yoneda00_Param_F G) (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
      ( 'PolyElement_ param @_ isFiniteness_Param_F , is_Parameter0_P , Heq_param0 , Yoneda10_Param_param0_morphism )
      <~~_ ( 'PolyElement_ param @_ isFiniteness_Param_F , is_Parameter0_P , Heq_param , Yoneda10_Param_param_morphism )

| PolyTransf_Param_default_cong :
    forall Yoneda00_Param_F Yoneda01_Param_F,
    forall (isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F),
    forall (Yoneda10_Param_param_ : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                                 (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_F )
      (Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                     (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          param = sval (Yoneda10_Param_param_ G param P is_Parameter0_P)
                       G (is_Parameter0_transp_rev_codom is_Parameter0_P (@unitParametrizator (Parameter0 G))) ),

    forall Yoneda00_Param_E Yoneda01_Param_E
      (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),

    forall (Yoneda10_Param_ee : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                             (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_E)
      Yoneda10_Param_ee_morphism
      (param_ee_ : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                     (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          'CoMod_( View_Param P ~> Param_E @_ (Yoneda10_Param_ee G param P is_Parameter0_P) )),

    forall (Yoneda10_Param_param0_ : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                                 (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_F )
      (Heq_param0 : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                     (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          param = sval (Yoneda10_Param_param0_ G param P is_Parameter0_P)
                       G (is_Parameter0_transp_rev_codom is_Parameter0_P (@unitParametrizator (Parameter0 G))) )
      (Yoneda10_Param_ee0 : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                              (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P), _ )
        Yoneda10_Param_ee0_morphism
        (param_ee0_ : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                     (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          'CoMod_( View_Param P ~> Param_E @_ (Yoneda10_Param_ee0 G param P is_Parameter0_P) )),

      ( param_ee0_( _ )(Finiteness.param1 isFiniteness_Param_F)(_)(Is_Parameter0 _)
          <~~_ param_ee_( _ )(Finiteness.param1 isFiniteness_Param_F)(_)(Is_Parameter0 _) ) ->

      ( param_ee0_( _ )(Finiteness.param2 isFiniteness_Param_F)(_)(Is_Parameter0 _)
          <~~_ param_ee_( _ )(Finiteness.param2 isFiniteness_Param_F)(_)(Is_Parameter0 _) ) ->

      [[_ param_ee0_ @_ isFiniteness_Param_F , Heq_param0 , Yoneda10_Param_ee0_morphism ]]
        <~~_ [[_ param_ee_ @_ isFiniteness_Param_F , Heq_param , Yoneda10_Param_ee_morphism ]]

| Formatting_cong : forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
      (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E)
      (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
    forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
      (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F)
      (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda10_Param_ff0 (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff0 )),
    forall Yoneda10_Param_ff Yoneda10_Form_ff
      (ff : 'CoMod( E ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff )),

    forall Yoneda10_Param_ff00 (param_ff0 : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff00 )),
    forall Yoneda10_Param_ff0 Yoneda10_Form_ff0
      (ff0 : 'CoMod( E ~> F @_ Yoneda10_Param_ff0 @^ Yoneda10_Form_ff0 )),

      param_ff0 <~~_ param_ff -> ff0 <~~ ff ->
      ( 'Formatting ff0 @_ param_ff0 ) <~~_ ( 'Formatting ff @_ param_ff )

(** ----- the constant conversions which are used during the polymorphism elimination ----- **)
| PolyCoMod_Param'UnitCoMod_Param :
forall Yoneda00_Param_E Yoneda01_Param_E (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
    forall Yoneda00_Param_F Yoneda01_Param_F (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda10_Param_ff (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff )),

    param_ff <~~_ ( param_ff o>CoMod_ (@'UnitCoMod_ Param_F) )

(**MEMO: not all cases of this conversion are necessary , when the postfix is [UnitCoMod_Param] , [UnitViewedFunctor_Param_default]  **)
| PolyCoMod_Param_UnitCoMod_Param :
forall Yoneda00_Param_E Yoneda01_Param_E (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
    forall Yoneda00_Param_F Yoneda01_Param_F (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda10_Param_ff (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff )),

    param_ff <~~_ ( 'UnitCoMod_ o>CoMod_ param_ff )

(** a.k.a View1_Param_View1_Param **)
| View1_Param_morphism :
    forall (G : obGenerator) (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P) (Q : obParametrizator) (q : 'Parametrizator( P ~> Q )), forall (G' : obGenerator) (P' : obParametrizator) (is_Parameter0_P' : is_Parameter0 G' P') (p : 'Parametrizator( P' ~> P )),
        ( 'View1_ is_Parameter0_P' (p o>Parametrizator q) )
          <~~_ ( 'View1_ is_Parameter0_P' p o>CoMod_ 'View1_ is_Parameter0_P q )

(** a.k.a ViewedFunctor1_Param_default_ViewedFunctor1_Param_default  **)
| ViewedFunctor1_Param_default_morphism :
    forall Yoneda00_Param_F Yoneda01_Param_F
      (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda00_Param_E Yoneda01_Param_E
      (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
    forall Yoneda10_Param_ff (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff )),
    forall Yoneda00_Param_D Yoneda01_Param_D (Param_D : @obCoMod_Param Yoneda00_Param_D Yoneda01_Param_D),
    forall Yoneda10_Param_dd (param_dd : 'CoMod_( Param_F ~> Param_D @_ Yoneda10_Param_dd )),
      ( 'ViewedFunctor1_ (param_ff o>CoMod_ param_dd ) )
        <~~_ ( 'ViewedFunctor1_ param_ff ) o>CoMod_ ( 'ViewedFunctor1_ param_dd )

(** a.k.a ViewedFunctor1_Param_default_UnitViewedFunctor_Param_default **)
| UnitViewedFunctor_Param_default_morphismPost :
    forall Yoneda00_Param_F Yoneda01_Param_F
      (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda00_Param_E Yoneda01_Param_E
      (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
    forall Yoneda10_Param_ff (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff )),
    forall Yoneda00_Param_D Yoneda01_Param_D
      (Param_D : @obCoMod_Param Yoneda00_Param_D Yoneda01_Param_D),
    forall Yoneda10_Param_dd (param_dd : 'CoMod_( Param_F ~> Param_D @_ Yoneda10_Param_dd )),

      ( ( param_ff o>CoMod_ param_dd ) o>CoMod_ 'UnitViewedFunctor_ )
        <~~_ ( ( param_ff o>CoMod_ 'UnitViewedFunctor_ ) o>CoMod_ ( 'ViewedFunctor1_ param_dd ) )

(** a.k.a ViewedFunctor1_Param_default_PolyTransf_Param_default **)
| PolyTransf_Param_default_morphism :
    forall Yoneda00_Param_F Yoneda01_Param_F,
    forall (isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F),
    forall (Yoneda10_Param_param_ : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                                 (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_F )
      (Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                     (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          param = sval (Yoneda10_Param_param_ G param P is_Parameter0_P)
                       G (is_Parameter0_transp_rev_codom is_Parameter0_P (@unitParametrizator (Parameter0 G))) ),

    forall Yoneda00_Param_E Yoneda01_Param_E (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),

    forall (Yoneda10_Param_ee : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                             (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_E)
      Yoneda10_Param_ee_morphism
      (param_ee_ : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                     (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          'CoMod_( View_Param P ~> Param_E @_ (Yoneda10_Param_ee G param P is_Parameter0_P) )),
    forall Yoneda00_Param_D Yoneda01_Param_D
      (Param_D : @obCoMod_Param Yoneda00_Param_D Yoneda01_Param_D),
    forall Yoneda10_Param_dd (param_dd : 'CoMod_( Param_E ~> Param_D @_ Yoneda10_Param_dd )),

      ( [[_ (fun G param P is_Parameter0_P => param_ee_(G)(param)(P)(is_Parameter0_P) o>CoMod_ param_dd)
             @_ isFiniteness_Param_F , Heq_param , (Yoneda10_PolyTransf_Param_default_morphism_Param_ee_morphism Yoneda10_Param_ee_morphism Yoneda10_Param_dd) ]] )
        <~~_ ( [[_ param_ee_ @_ isFiniteness_Param_F , Heq_param , Yoneda10_Param_ee_morphism ]]
              o>CoMod_ ( 'ViewedFunctor1_ param_dd ) )

(** a.k.a UnitViewedFunctor_Param_default_PolyCoMod_Param **)
| UnitViewedFunctor_Param_default_morphismPre :
    forall Yoneda00_Param_F Yoneda01_Param_F
      (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda00_Param_E Yoneda01_Param_E
      (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
    forall Yoneda10_Param_ff (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff )),
    forall Yoneda00_Param_D Yoneda01_Param_D (Param_D : @obCoMod_Param Yoneda00_Param_D Yoneda01_Param_D),
    forall Yoneda10_Param_dd (param_dd : 'CoMod_( Param_D ~> Param_E @_ Yoneda10_Param_dd )),
      ( ( param_dd o>CoMod_ param_ff ) o>CoMod_ 'UnitViewedFunctor_ )
        <~~_ ( param_dd o>CoMod_ ( param_ff o>CoMod_ 'UnitViewedFunctor_ ) )

(** a.k.a PolyElement_Param_default_View1_Param **)
| PolyElement_Param_default_morphism :
    forall Yoneda00_Param_F Yoneda01_Param_F,
    forall (isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F),
    forall (Yoneda10_Param_param_ : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                                 (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_F )
      (Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                     (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          param = sval (Yoneda10_Param_param_ G param P is_Parameter0_P)
                       G (is_Parameter0_transp_rev_codom is_Parameter0_P (@unitParametrizator (Parameter0 G))) )
      Yoneda10_Param_param_morphism,
    forall (G : obGenerator) (param : Yoneda00_Param_F G) (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
    forall (H : obGenerator) (Q : obParametrizator) (is_Parameter0_Q : is_Parameter0 H Q) (p : 'Parametrizator( Q ~> P )),
      ( 'PolyElement_ ( sval (Yoneda10_Param_param_ G param P is_Parameter0_P) H (is_Parameter0_transp_dom is_Parameter0_Q p) )
                      @_ isFiniteness_Param_F , is_Parameter0_Q , Heq_param , Yoneda10_Param_param_morphism )
        <~~_ ( 'View1_ is_Parameter0_Q p o>CoMod_ 'PolyElement_ param @_ isFiniteness_Param_F , is_Parameter0_P , Heq_param , Yoneda10_Param_param_morphism )

| PolyTransf_Param_default_PolyElement_Param_default :
    forall Yoneda00_Param_F Yoneda01_Param_F,
    forall (isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F),
    forall (Yoneda10_Param_param_ : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                                 (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_F )
      (Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                     (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          param = sval (Yoneda10_Param_param_ G param P is_Parameter0_P)
                       G (is_Parameter0_transp_rev_codom is_Parameter0_P (@unitParametrizator (Parameter0 G))) ),

    forall Yoneda00_Param_E Yoneda01_Param_E
      (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),

    forall (Yoneda10_Param_ee : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                             (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_E)
      Yoneda10_Param_ee_morphism
      (param_ee_ : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                     (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          'CoMod_( View_Param P ~> Param_E @_ (Yoneda10_Param_ee G param P is_Parameter0_P) )),

    forall (Yoneda10_Param_param0_ : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                                 (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_F )
      (Heq_param0 : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                     (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          param = sval (Yoneda10_Param_param0_ G param P is_Parameter0_P)
                       G (is_Parameter0_transp_rev_codom is_Parameter0_P (@unitParametrizator (Parameter0 G))) )
      Yoneda10_Param_param0_morphism ,
    forall (G : obGenerator) (param : Yoneda00_Param_F G) (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),

      ( ( param_ee_(G)(param)(P)(is_Parameter0_P) ) o>CoMod_ 'UnitViewedFunctor_ )
        <~~_ ( ( 'PolyElement_ param @_ isFiniteness_Param_F , is_Parameter0_P , Heq_param0, Yoneda10_Param_param0_morphism  )
                o>CoMod_ [[_ param_ee_ @_ isFiniteness_Param_F , Heq_param , Yoneda10_Param_ee_morphism ]]  )

| PolyTransf_Param_default'PolyElement_Param_default :
    forall Yoneda00_Param_F Yoneda01_Param_F,
    forall (isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F),
    forall (Yoneda10_Param_param_ : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                                 (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_F )
      (Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                     (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          param = sval (Yoneda10_Param_param_ G param P is_Parameter0_P)
                       G (is_Parameter0_transp_rev_codom is_Parameter0_P (@unitParametrizator (Parameter0 G))) )
      Yoneda10_Param_param_morphism,

    forall (Yoneda10_Param_param0_ : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                                 (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_F )
      (Heq_param0 : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                     (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          param = sval (Yoneda10_Param_param0_ G param P is_Parameter0_P)
                       G (is_Parameter0_transp_rev_codom is_Parameter0_P (@unitParametrizator (Parameter0 G))) )
      Yoneda10_Param_param0_morphism,

      (**TODO: PROBLEM ? SOLVED BY [PolyTransf_Param_default_cong] ! refer to [PolyTransf_default'PolyElement_default] above *)
  ( ( @'UnitCoMod_ (ViewingFunctor_Param_default isFiniteness_Param_F) ) o>CoMod_ 'UnitViewedFunctor_ )
    <~~_  ( [[_ (fun G (param : Yoneda00_Param_F G) (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P)
               => ( 'PolyElement_ param @_ isFiniteness_Param_F , is_Parameter0_P , Heq_param , Yoneda10_Param_param_morphism ) )
              @_ isFiniteness_Param_F , Heq_param0 , Yoneda10_Param_param0_morphism ]] )

(** a.k.a Formatting_Formatting **)
| Formatting_morphism :
    forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
      (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E)
      (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
    forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
      (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F)
      (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda10_Param_ff0 (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff0 )),
    forall Yoneda10_Param_ff Yoneda10_Form_ff (ff : 'CoMod( E ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff )),

    forall Yoneda00_Form_D Yoneda01_Form_D Yoneda00_Param_D Yoneda01_Param_D Yoneda10_FormParam_D
      (D : @obCoMod Yoneda00_Form_D Yoneda01_Form_D Yoneda00_Param_D Yoneda01_Param_D Yoneda10_FormParam_D)
      (Param_D : @obCoMod_Param Yoneda00_Param_D Yoneda01_Param_D),
    forall Yoneda10_Param_dd0 (param_dd : 'CoMod_( Param_D ~> Param_E @_ Yoneda10_Param_dd0 )),
    forall Yoneda10_Param_dd Yoneda10_Form_dd
      (dd : 'CoMod( D ~> E @_  Yoneda10_Param_dd @^ Yoneda10_Form_dd )),

      ( 'Formatting ( dd o>CoMod ff ) @_ ( param_dd o>CoMod_ param_ff ) )
        <~~_ ( ( 'Formatting dd @_  param_dd ) o>CoMod_ ( 'Formatting  ff @_ param_ff ) )

where "param_ff0  <~~_ param_ff" := (@convCoMod_Param _ _ _ _ _ _ _ param_ff _ param_ff0).

Hint Constructors convCoMod convCoMod_Param : core.

Scheme convCoMod_convCoMod_Param_ind := Induction for convCoMod Sort Prop
    with convCoMod_Param_convCoMod_ind := Induction for convCoMod_Param Sort Prop.
Combined Scheme convCoMod_convCoMod_Param_mutind from
         convCoMod_convCoMod_Param_ind, convCoMod_Param_convCoMod_ind.
(** # #
#+END_SRC

** Same sense-decoding for convertible morphisms

  Because of the embedded sense-decoding extra-indexes/arguments in the datatype-families [morCoMod] of the morphisms , the conversion-relation shall convert across two morphisms whose sense-decoding datatype-indexes/arguments are not syntactically/grammatically-the-same . But oneself does show that , by logical-deduction [convCoMod_sense_mut] , these two sense-decodings are indeed propositionally equal ( « sensible lemma » , "soundness lemma" ) .   The converse inference is the « sense-completeness lemma » , whose deduction will lack the finished cut-elimination lemma . Such sense-completeness lemma is expected because : some sense-completeness lemma does hold for adjunctions and for comonad and for (cartesian) products but using the combinatorial "links" sense ( in the style of Dosen ) ; the attention is that this combinatorial "links" sense is the combinatorial essense of this ongoing (algebraic) metafunctors ( "presheaf" ) sense ; therefore those completeness lemma shall transfer .

  Memo that the lemma [convCoMod_sense_mut] will only be used during the polymorphism/cut-elimination resolution [solveCoMod] [solveCoMod_Param] to show/transfer the logical-properties which are carried-as-arguments by the many morphisms constructors ( [Heq_param] , [Heq_subst] , [Yoneda10_Form_ee_morphism] ... ) .

#+BEGIN_SRC coq :exports both :results silent # # **)
Lemma convCoMod_sense_mut :
( forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
    (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E),
    forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
      (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F),
    forall Yoneda10_Param_ff Yoneda10_Form_ff (ff : 'CoMod( E ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff )),
    forall Yoneda10_Param_ff0 Yoneda10_Form_ff0 (ff0 : 'CoMod( E ~> F @_ Yoneda10_Param_ff0 @^ Yoneda10_Form_ff0 )),
      ff0 <~~ ff -> (forall G' param', (sval Yoneda10_Param_ff0 G') param' = (sval Yoneda10_Param_ff G') param') /\
  (forall G' param', forall form', sval (sval Yoneda10_Form_ff0 G' param' form') = sval (sval Yoneda10_Form_ff G' param' form')) )
/\ ( forall Yoneda00_Param_E Yoneda01_Param_E (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
    forall Yoneda00_Param_F Yoneda01_Param_F (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda10_Param_ff (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff )),
    forall Yoneda10_Param_ff0 (param_ff0 : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff0 )),
      param_ff0 <~~_ param_ff ->
  (forall G', (sval Yoneda10_Param_ff0 G') =1 (sval Yoneda10_Param_ff G')) ).
Proof.
  apply: convCoMod_convCoMod_Param_mutind.
  (**  ----- the total/(multi-step) conversions -----  **)
  - (** convCoMod_Refl *) split; reflexivity.
  - (** convCoMod_Trans *) intros until 1. intros gg_eq . intros until 1. intros uTrans_eq. split.
    + intros; erewrite <- (proj1 gg_eq); [ | reflexivity.. ]. apply: (proj1 uTrans_eq); eassumption.
    + intros; erewrite <- (proj2 gg_eq); [ | reflexivity.. ]. apply: (proj2 uTrans_eq); eassumption.
  - (** PolyCoMod_cong *)  intros until 1. intros ff'_eq . intros ? ff__eq . split.
    + intros. simpl. rewrite (proj1 ff'_eq). rewrite (proj1 ff__eq).  reflexivity.
    + intros ? param' form' .  simpl.
      erewrite (proj2 (proj2_sig Yoneda10_Form_ff'0)).
      * exact: (proj2 ff'_eq).
      * simpl; apply: (proj2 ff__eq).
  - (** ViewedFunctor1_default_cong *)
    intros until 3. intros Heq_param_ff ? Heq_ff. split.
    + (**MEMO: the induction hypothesis for the code [param_ff] is used in this first half of the congruence goal *)
      intros. rewrite Heq_param Heq_param0. exact: Heq_param_ff.
    + exact: (proj2 Heq_ff).
  - (** UnitViewedFunctor_default_cong *) intros. assumption.
  - (** PolyElement_default_cong *) intros until form0. intros Hform. split.
    + intros. reflexivity.
    + intros. simpl. rewrite Hform. reflexivity.
  - (* PolyTransf_default_cong *)
    intros until ee0_. intros ? Heq_param1 ? Heq_param2  ? Heq_param1_form1 ? Heq_param1_form2 ? Heq_param2_form1 ? Heq_param2_form2.
    intros. simpl. split.
    + (**MEMO: the param codes [param_ee0_] for [PolyTransf_default] are necessary to show this first half of the congruence goal ;
         these param codes [param_ee0_] then force the presence of the param codes [param_ff] for [ViewedFunctor1_default] *)
      intros; destruct (Finiteness.is_viewingFunctorParamElement12_allP isFiniteness_Param_F param');
        [rewrite Heq_param1 | rewrite Heq_param2 ]; reflexivity.
    + intros. destruct (Finiteness.is_viewingFunctorParamElement12_allP isFiniteness_Param_F param');
        destruct (Finiteness.is_viewingFunctorElement12_allP isFiniteness_FormParam_F form');
        [rewrite (proj2 Heq_param1_form1) | rewrite (proj2  Heq_param1_form2) | rewrite (proj2 Heq_param2_form1) | rewrite (proj2  Heq_param2_form2) ]; reflexivity.
  - (** Forget_cong *) intros until 1. intros  HForget ? Hee. split.
    + intros. simpl. rewrite -Heq_subst -Heq_subst_0. apply: (proj1 Hee).
    + intros. simpl. rewrite (proj2 Hee). apply: (proj2 (proj2_sig Yoneda10_Form_ee)). reflexivity.
  - (** Remember_cong*) intros until Heq_subst_0. intros Heq_param1 ? HForget ? Hll. split.
    + intros. simpl. exact: Heq_param1.
    + intros. simpl. apply: Yoneda00_Form_Subst_quotientLogical; simpl. exact: (proj2 Hll).
  - (** PolyCoMod'UnitCoMod *) split; reflexivity.
  - (** PolyCoMod_UnitCoMod *) intros; simpl. split.
    + reflexivity.
    + intros. apply: (proj2 (proj2_sig Yoneda10_Form_ff)). reflexivity.
  - (** View1_morphism *)  intros; move; simpl; split.
    + intros. rewrite Parameter_morphism.  exact: polyParametrizator_morphism.
    + intros. exact: polyGenerator_morphism.
  - (** ViewedFunctor1_default_morphism *)
    split; reflexivity.
  - (** UnitViewedFunctor_default_morphismPost *)
    split; reflexivity.
  - (** PolyTransf_default_morphism *)
    intros; simpl. split.
    + intros; rewrite Heq_param_dd; reflexivity.
    + intros; apply: (proj2 (proj2_sig Yoneda10_Form_dd)). reflexivity.
  - (** UnitViewedFunctor_default_morphismPre *)
    split; reflexivity.
  - (** PolyElement_default_morphism *)
    intros ? Yoneda01_Form_F; intros; simpl. split.
    + intros; simpl. symmetry. apply: Yoneda10_Param_morphism_Parameter1;
                                 [ exact: Heq_param | exact: Yoneda10_Param_param_morphism].
    + intros; exact: (proj1 (proj2_sig Yoneda01_Form_F)).
  - (** PolyTransf_default_PolyElement_default *) intros; simpl. split; intros.
    + rewrite Heq_param_ee.
      rewrite [param' in LHS]polyParametrizator_unitParametrizator.
      exact: Yoneda10_Param_ee0_morphism.
    + have -> : sval (sval (Yoneda10_Form_ee G param form) G' param' form') =
               sval (sval (Yoneda10_Form_ee G param form) G' (unitParametrizator o>Parametrizator (Parameter1 (sval form')))
                          (unitGenerator_AtParam o>GeneratorAtParam (sval form') ))
      by apply: (proj2 (proj2_sig (Yoneda10_Form_ee G param form))); simpl; exact: polyGenerator_unitGenerator.
    rewrite [LHS]Yoneda10_Form_ee_morphism. apply: Yoneda10_Form_ee_quotientLogical; simpl. reflexivity.
  - (** Remember_morphism *)
    intros; simpl. split; intros.
    + reflexivity.
    + apply: Yoneda00_Form_Subst_quotientLogical; simpl. reflexivity.
  - (** Forget_morphism *)
    intros; simpl. split; intros.
    + reflexivity.
    + apply: (proj2 (proj2_sig Yoneda10_Form_dd)). reflexivity.
  - (** Remember_Forget *)
    intros; simpl. split; intros.
    + simpl. rewrite -Heq_subst. rewrite Heq_param /= -Heq_subst_0. reflexivity.
    + apply: (proj2 (proj2_sig Yoneda10_Form_ee)). reflexivity.
  - (** PolyTransf_default'PolyElement_default *)
    intros; simpl. split; intros.
    + exact: Heq_param0.
    + exact: (proj2 (proj2_sig Yoneda01_Form_F)).
  - (** Remember'Forget *)
    intros; simpl. split; intros.
    + reflexivity.
    + apply: Yoneda00_Form_Subst_quotientLogical; simpl. reflexivity.
  (** - Forget'Remember :  none such confluence *)
  - (** convCoMod_Param_Refl *) intros; move. reflexivity.
  - (** convCoMod_Param_Trans *)
    intros until 1. intros gg_eq . intros until 1. intros uTrans_eq.
    intros; move; intros. erewrite <- gg_eq; [ | reflexivity.. ]. apply: uTrans_eq; eassumption.
  - (** PolyCoMod_Param_cong *) intros until 1. intros ff'_eq .
    intros ? ff__eq  . intros; move; intros; simpl.
    rewrite ff'_eq  ff__eq. reflexivity.
  - (** ViewedFunctor1_Param_default_cong  *) tauto.
  - (** UnitViewedFunctor_Param_default_cong *) tauto.
  - (** PolyElement_Param_default_cong *) intros until 5. intros Heq. exact: Heq.
  - (** PolyTransf_Param_default_cong *)
    intros until param_ee0_. intros ? Heq1 ? Heq2. intros; move; intros param'. simpl.
    destruct (Finiteness.is_viewingFunctorParamElement12_allP isFiniteness_Param_F param');
      [rewrite Heq1 | rewrite Heq2 ]; reflexivity.
  - (** Formatting_cong *) intros until ff0. intros ? IHeq1 ? IHeq2 .
    intros.
    intros; move; intros; rewrite /= /ssr_have /=.
    apply: Yoneda00_Form_Subst_quotientLogical; simpl. simpl in *.
    exact: (proj2 IHeq2).  (***TODOP: HERE *)
  - (** PolyCoMod_Param'UnitCoMod_Param *) intros; move; reflexivity.
  - (** PolyCoMod_Param_UnitCoMod_Param *) intros; move; reflexivity.
  - (** View1_Param_morphism *)
    intros; move; intros; simpl. exact: polyParametrizator_morphism.
  - (** ViewedFunctor1_Param_default_morphism *)
    intros; move; reflexivity.
  - (** UnitViewedFunctor_default_morphismPost *)
    intros; move; reflexivity.
  - (** PolyTransf_Param_default_morphism *)
    intros; move; reflexivity.
  - (** UnitViewedFunctor_Param_default_morphismPre *)
    intros; move; reflexivity.
  - (** PolyElement_Param_default_morphism *)
    intros until G'. destruct is_Parameter0_Q. move; intros; simpl.
    symmetry. exact: Yoneda10_Param_param_morphism.
  - (** PolyTransf_Param_default_PolyElement_Param_default *) intros; move; intros param'; simpl.
    rewrite [param' in LHS]polyParametrizator_unitParametrizator.
    rewrite [LHS](Yoneda10_Param_ee_morphism _ _ P is_Parameter0_P _ (Heq_param0 _ _ P is_Parameter0_P)). reflexivity.
  - (** PolyTransf_default'PolyElement_default *)
    intros; move; intros param'; simpl.
    exact: Heq_param.
    (** exact: (proj2 (proj2_sig Yoneda01_Form_F)). *)
  - (** Formatting_morphism *) intros; move; intros; rewrite /= /ssr_have /= .
    intros.
    apply: Yoneda00_Form_Subst_quotientLogical; simpl. apply: (proj2 (proj2_sig  Yoneda10_Form_ff)); simpl.
    apply: (proj2 (proj2_sig  Yoneda10_Form_dd)); simpl. reflexivity.
Qed.

Definition convCoMod_sense := proj1 convCoMod_sense_mut.
Definition convCoMod_sense_param := proj2 convCoMod_sense_mut.
(** # #
#+END_SRC

** Linear total/asymptotic grade and the degradation lemma

  As is common , the grade of the composition constructor [PolyCoMod] is defined as the double of the (sucessor of the) sum of the grades of its arguments ; such doubling is such that for each of the polymorphism conversion-constructors , the enclosing/outer constructor in the contractum has less « effect » than itself in the redex . For example , this polymorphism conversion [(ConstructorX (atomA o> atomB))  <~~  ((ConstructorX atomA) o> atomB)] will produce the degradation [(1 + (2 + 2 + 2))  <  ((2 + 2) + 2 + 2)] .

  Memo that the grade of the summing/colimiting/copairing form-morphism constructor [PolyTransf_default] is defined , as some (successor of the) sum of the maximum of the grades of the component form-morphisms ( over only the viewing-elements ) plus the maximum of the grades of the component parametrizator-morphisms ( over only the viewing-elements ) .

  Elsewhere , memo that if the conversion-relation constructors [convCoMod_Refl] [convCoMod_Param_Refl] were absent , then oneself would get some degradation lemma with tight/strict less-than : [( grade ff0 < grade ff )] ; this is the tight/strict-degrading which will occur during the polymorphism/cut-elimination resolution ( by the automatic-arithmetic-tactic calls therein ) .

#+BEGIN_SRC coq :exports both :results silent # # **)
Notation max m n := (Nat.add m (Nat.sub n m)).
Arguments Nat.sub : simpl nomatch.
Arguments Nat.add : simpl nomatch.

Definition grade_mut :
  ( forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
      (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E),
    forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
      (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F),
    forall Yoneda10_Param_ff Yoneda10_Form_ff (ff : 'CoMod( E ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff )), nat ) *
( forall Yoneda00_Param_E Yoneda01_Param_E (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
    forall Yoneda00_Param_F Yoneda01_Param_F (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda10_Param_ff (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff )), nat )%type .
Proof.
  apply: morCoMod_morCoMod_Param_mutrect.
  - (** PolyCoMod *) intros Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F F Yoneda00_Form_F' Yoneda01_Form_F' Yoneda00_Param_F' Yoneda01_Param_F' Yoneda10_FormParam_F' F' Yoneda10_Param_ff' Yoneda10_Form_ff'  ff' grade_ff' Yoneda00_Form_F'' Yoneda01_Form_F'' Yoneda00_Param_F'' Yoneda01_Param_F'' Yoneda10_FormParam_F'' F'' Yoneda10_Param_ff_ Yoneda10_Form_ff_ ff_ grade_ff_ .
    exact: ( 2 * (S (grade_ff' + grade_ff_ )%nat ) )%nat .
  - (** UnitCoMod *) intros Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F F.
    exact: (S ( (** gradeOb F = *) O )).
  - (** View1 *) intros G H g.
    exact: (S O).
  - (** ViewedFunctor1_default *) intros Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F F Param_F Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E E Param_E
                                        Yoneda10_Param_ff0 param_ff grade_param_ff Yoneda10_Param_ff Yoneda10_Form_ff ff grade_ff Heq_param.
    exact: (S ( grade_param_ff + grade_ff )%nat ).
  - (**  UnitViewedFunctor_default *) intros Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F F Param_F Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E E Yoneda10_Param_ff
                                            Yoneda10_Form_ff ff grade_ff.
    exact: (S grade_ff).
  - (** PolyElement_default *) intros Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F isFiniteness_Param_F isFiniteness_FormParam_F   Yoneda10_Param_param_ Heq_param Yoneda10_Param_param_morphism G param form.
    exact: (S (S O)).
  - (** PolyTransf_default *) intros Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F isFiniteness_Param_F isFiniteness_FormParam_F  Yoneda10_Param_param_ Heq_param Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
                                    E Param_E Yoneda10_Param_ee0 param_ee0_ grade_param_ee0_ Yoneda10_Param_ee Yoneda10_Form_ee Heq_param_ee Yoneda10_Param_ee0_morphism Yoneda10_Form_ee_quotientLogical Yoneda10_Form_ee_morphism ee_ grade_ee_.
    exact: (S (S ( (max (grade_param_ee0_(_)(Finiteness.param1 isFiniteness_Param_F))%nat
                        (grade_param_ee0_(_)(Finiteness.param2 isFiniteness_Param_F))%nat) +
                   (max
                    (max (grade_ee_( _ )( _ )(Finiteness.form1 isFiniteness_FormParam_F (Finiteness.param1 isFiniteness_Param_F)))
                         (grade_ee_( _ )( _ )(Finiteness.form2 isFiniteness_FormParam_F (Finiteness.param1 isFiniteness_Param_F))))%nat
                    (max (grade_ee_( _ )( _ )(Finiteness.form1 isFiniteness_FormParam_F (Finiteness.param2 isFiniteness_Param_F)))
                         (grade_ee_( _ )( _ )(Finiteness.form2 isFiniteness_FormParam_F (Finiteness.param2 isFiniteness_Param_F))))%nat))%nat )%nat)%nat.
  - (** Forget *) intros Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F F Param_F Yoneda00_Param_SubstF Yoneda01_Param_SubstF Param_SubstF Yoneda10_Param_Forget param_Forget grade_param_Forget
                         Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E E Yoneda10_Param_ee Yoneda10_Form_ee ee grade_ee Yoneda10_Param_Forget' Heq_subst.
    exact: (S (S ( grade_param_Forget + grade_ee )%nat )).
  - (** Remember *) intros Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F F Param_F Yoneda00_Param_SubstF Yoneda01_Param_SubstF Param_SubstF Yoneda10_Param_Forget param_Forget grade_param_Forget
            L Yoneda10_Param_ll Yoneda10_Form_ll ll grade_ll  Yoneda10_Param_ll_ Heq_param Yoneda10_Param_Forget' Heq_subst.
    exact: (S (S ( grade_param_Forget + grade_ll )%nat )).
  - (** PolyCoMod_Param *) intros Yoneda00_Param_F Yoneda01_Param_F Param_F Yoneda00_Param_F' Yoneda01_Param_F' Param_F' Yoneda10_Param_ff' param_ff' grade_param_ff' Yoneda00_Param_F'' Yoneda01_Param_F'' Param_F'' Yoneda10_Param_ff_ param_ff_ grade_param_ff_.
    exact: ( 2 * (S (grade_param_ff' + grade_param_ff_)%nat ) )%nat .
  - (** UnitCoMod_Param *) intros Yoneda00_Param_F Yoneda01_Param_F Param_F.
    exact: (S ( (** gradeOb_Param Param_F = *) O )).
  - (** View1_Param *) intros G P is_Parameter0_P Q p.
    exact: (S O).
  - (** ViewedFunctor1_Param_default *) intros Yoneda00_Param_F Yoneda01_Param_F Param_F Yoneda00_Param_E Yoneda01_Param_E Param_E Yoneda10_Param_ff param_ff grade_param_ff.
    exact: (S grade_param_ff).
  - (**  UnitViewedFunctor_Param_default *) intros Yoneda00_Param_F Yoneda01_Param_F Param_F Yoneda00_Param_E Yoneda01_Param_E Param_E Yoneda10_Param_ff param_ff grade_param_ff.
    exact: (S grade_param_ff).
  - (** PolyElement_Param_default *) intros Yoneda00_Param_F Yoneda01_Param_F isFiniteness_Param_F Yoneda10_Param_param_ Heq_param Yoneda10_Param_param_morphism G param P is_Parameter0_P.
    exact: (S (S O)).
  - (** PolyTransf_Param_default *) intros Yoneda00_Param_F Yoneda01_Param_F isFiniteness_Param_F Yoneda10_Param_param_ Heq_param Yoneda00_Param_E Yoneda01_Param_E Param_E Yoneda10_Param_ee Yoneda10_Param_ee_morphism param_ee_ grade_param_ee_.
    exact: (S (S ( (max (grade_param_ee_( _ )(Finiteness.param1 isFiniteness_Param_F)(_)(Is_Parameter0 _))
                         (grade_param_ee_( _ )(Finiteness.param2 isFiniteness_Param_F)(_)(Is_Parameter0 _)))))).
  - (** Formatting *) intros Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E E Param_E Yoneda00_Form_F Yoneda01_Form_F
                          Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F F Param_F Yoneda10_Param_ff0 param_ff grade_param_ff Yoneda10_Param_ff Yoneda10_Form_ff ff grade_ff .
    exact: (S ( grade_param_ff + grade_ff )%nat ).
Defined.

Definition grade := fst grade_mut.
Definition grade_param := snd grade_mut.
Arguments grade : simpl nomatch.
Arguments grade_param : simpl nomatch.

Lemma grade_mut_PolyCoMod:
  forall (Yoneda00_Form_F : obGenerator -> Type) (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F) (Yoneda00_Param_F : obGenerator -> Type) (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
    (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F) (F : obCoMod Yoneda10_FormParam_F) (Yoneda00_Form_F' : obGenerator -> Type)
    (Yoneda01_Form_F' : Yoneda01_data Yoneda00_Form_F') (Yoneda00_Param_F' : obGenerator -> Type) (Yoneda01_Param_F' : Yoneda01_data Yoneda00_Param_F')
    (Yoneda10_FormParam_F' : Yoneda10_data Yoneda01_Form_F' Yoneda01_Param_F') (F' : obCoMod Yoneda10_FormParam_F')
    (Yoneda10_Param_ff' : Yoneda10_data Yoneda01_Param_F' Yoneda01_Param_F) (Yoneda10_Form_ff' : Yoneda10_Form_data Yoneda10_FormParam_F' Yoneda10_FormParam_F Yoneda10_Param_ff'),
  forall (ff' : 'CoMod( F' ~> F @_ Yoneda10_Param_ff' @^ Yoneda10_Form_ff' )),
  forall (Yoneda00_Form_F'' : obGenerator -> Type) (Yoneda01_Form_F'' : Yoneda01_data Yoneda00_Form_F'') (Yoneda00_Param_F'' : obGenerator -> Type) (Yoneda01_Param_F'' : Yoneda01_data Yoneda00_Param_F'')
    (Yoneda10_FormParam_F'' : Yoneda10_data Yoneda01_Form_F'' Yoneda01_Param_F'') (F'' : obCoMod Yoneda10_FormParam_F'')
    (Yoneda10_Param_ff_ : Yoneda10_data Yoneda01_Param_F'' Yoneda01_Param_F') (Yoneda10_Form_ff_ : Yoneda10_Form_data Yoneda10_FormParam_F'' Yoneda10_FormParam_F' Yoneda10_Param_ff_),
  forall (ff_ : 'CoMod( F'' ~> F' @_ Yoneda10_Param_ff_ @^ Yoneda10_Form_ff_ )),                                                                                grade ( ff_ o>CoMod ff' ) = ( 2 * (S ((grade ff')%nat + (grade ff_ )%nat)%nat ) )%nat.
Proof. reflexivity. Qed.

Lemma grade_mut_UnitCoMod:
  forall (Yoneda00_Form_F : obGenerator -> Type) (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F) (Yoneda00_Param_F : obGenerator -> Type) (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
    (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F),
  forall (F : obCoMod Yoneda10_FormParam_F),
    grade (@'UnitCoMod F ) = (S ( O )).
Proof. reflexivity. Qed.

Lemma grade_mut_View1:
  forall G H : obGenerator, forall (g : 'Generator( H ~> G )), grade ('View1 g) = (S O) .
Proof. reflexivity. Qed.

Lemma grade_mut_ViewedFunctor1:
forall (Yoneda00_Form_F : obGenerator -> Type)
 (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F)
 (Yoneda00_Param_F : obGenerator -> Type)
 (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
 (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F)
 (F : obCoMod Yoneda10_FormParam_F)
 (Param_F : obCoMod_Param Yoneda01_Param_F)
 (Yoneda00_Form_E : obGenerator -> Type)
 (Yoneda01_Form_E : Yoneda01_data Yoneda00_Form_E)
 (Yoneda00_Param_E : obGenerator -> Type)
 (Yoneda01_Param_E : Yoneda01_data Yoneda00_Param_E)
 (Yoneda10_FormParam_E : Yoneda10_data Yoneda01_Form_E Yoneda01_Param_E)
 (E : obCoMod Yoneda10_FormParam_E)
 (Param_E : obCoMod_Param Yoneda01_Param_E)
 Yoneda10_Param_ff0 (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff0 ))
 Yoneda10_Param_ff Yoneda10_Form_ff (ff : 'CoMod( E ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff )) Heq_param,
  grade ( 'ViewedFunctor1 ff @_ Heq_param = param_ff )
    = (S ( grade_param param_ff + grade ff)%nat).
Proof. reflexivity. Qed.

Lemma grade_mut_UnitViewedFunctor:
  forall (Yoneda00_Form_F : obGenerator -> Type) (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F) (Yoneda00_Param_F : obGenerator -> Type) (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
    (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F) (F : obCoMod Yoneda10_FormParam_F) (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F)  (Yoneda00_Form_E : obGenerator -> Type)
    (Yoneda01_Form_E : Yoneda01_data Yoneda00_Form_E) (Yoneda00_Param_E : obGenerator -> Type) (Yoneda01_Param_E : Yoneda01_data Yoneda00_Param_E)
    (Yoneda10_FormParam_E : Yoneda10_data Yoneda01_Form_E Yoneda01_Param_E) (E : obCoMod Yoneda10_FormParam_E)
    (Yoneda10_Param_ff : Yoneda10_data Yoneda01_Param_E Yoneda01_Param_F),
  forall Yoneda10_Form_ff : Yoneda10_Form_data Yoneda10_FormParam_E Yoneda10_FormParam_F Yoneda10_Param_ff,
  forall (ff : 'CoMod( E ~> F  @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff )),
    grade ( ff  o>CoMod 'UnitViewedFunctor @_ Param_F )
    = (S ( grade ff)%nat) .
Proof. reflexivity. Qed.

Lemma grade_mut_PolyElement_default:
  forall (Yoneda00_Form_F : obGenerator -> Type) (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F) (Yoneda00_Param_F : obGenerator -> Type) (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
    (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F)
    (isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F)
      (isFiniteness_FormParam_F : Finiteness.isFiniteness_FormParam_ Yoneda10_FormParam_F)
 (Yoneda10_Param_param_ : forall G : obGenerator, Yoneda00_Param_F G -> Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F)
  (Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G), param = sval (Yoneda10_Param_param_ G param) G unitParametrizator)
  Yoneda10_Param_param_morphism  (G : obGenerator)
  (param : Yoneda00_Param_F G)
  (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
    grade ( 'PolyElement form @_ isFiniteness_Param_F , Heq_param , Yoneda10_Param_param_morphism @^ isFiniteness_FormParam_F ) = (S (S O )) .
Proof. reflexivity. Qed.

Lemma grade_mut_PolyTransf_default:
forall (Yoneda00_Form_F : obGenerator -> Type)
 (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F)
 (Yoneda00_Param_F : obGenerator -> Type)
 (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
 (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F)
(isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F)
(isFiniteness_FormParam_F : Finiteness.isFiniteness_FormParam_ Yoneda10_FormParam_F)
(Yoneda10_Param_param_ : forall G : obGenerator, Yoneda00_Param_F G -> Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F)
 (Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G), param = sval (Yoneda10_Param_param_ G param) G unitParametrizator)
 (Yoneda00_Form_E : obGenerator -> Type)
 (Yoneda01_Form_E : Yoneda01_data Yoneda00_Form_E)
 (Yoneda00_Param_E : obGenerator -> Type)
 (Yoneda01_Param_E : Yoneda01_data Yoneda00_Param_E)
 (Yoneda10_FormParam_E : Yoneda10_data Yoneda01_Form_E Yoneda01_Param_E)
 (E : obCoMod Yoneda10_FormParam_E)
 (Param_E : obCoMod_Param Yoneda01_Param_E)
  (Yoneda10_Param_ee0 : forall G : obGenerator, Yoneda00_Param_F G -> Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_E)
  (param_ee0_ : forall (G : obGenerator) (param : Yoneda00_Param_F G), 'CoMod_ ( View_Param (Parameter0 G) ~> Param_E @_ Yoneda10_Param_ee0 G param ))
  (Yoneda10_Param_ee : forall (G : obGenerator) (param : Yoneda00_Param_F G), Yoneda00_AtParam_ Yoneda10_FormParam_F param -> Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_E)
  (Yoneda10_Form_ee : forall (G : obGenerator) (param : Yoneda00_Param_F G) (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
                     Yoneda10_Form_data (Yoneda10_FormParam_View G) Yoneda10_FormParam_E (Yoneda10_Param_ee G param form))
  (Heq_param_ee : forall (G : obGenerator) (param : Yoneda00_Param_F G) (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param) (G' : obGenerator) (param' : Yoneda00_Param_View (Parameter0 G) G'),
                 sval (Yoneda10_Param_ee G param form) G' param' = sval (Yoneda10_Param_ee0 G param) G' param')
  Yoneda10_Param_ee0_morphism
 (Yoneda10_Form_ee_quotientLogical : forall (G : obGenerator) (param : Yoneda00_Param_F G) (form : {form : Yoneda00_Form_F G | sval Yoneda10_FormParam_F G form = param}) (param' : Yoneda00_Param_F G)
                                       (form' : {form0 : Yoneda00_Form_F G | sval Yoneda10_FormParam_F G form0 = param'}),
                                     sval form = sval form' ->
                                     forall (G0 : obGenerator) (param0 : Yoneda00_Param_View (Parameter0 G) G0) (form0 : 'Generator ( G0 ~> G @_ param0 )),
                                     sval (sval (Yoneda10_Form_ee G param form) G0 param0 form0) = sval (sval (Yoneda10_Form_ee G param' form') G0 param0 form0))
 (Yoneda10_Form_ee_morphism : forall (G G' : obGenerator) (g : 'Generator( G' ~> G )) (param : Yoneda00_Param_F G) (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param) (G'' : obGenerator)
                                (param' : Yoneda00_Param_View (Parameter0 G') G'') (form' : 'Generator ( G'' ~> G' @_ param' )),
                              sval (sval (Yoneda10_Form_ee G param form) G'' (param' o>Parametrizator Parameter1 g) (form' o>GeneratorAtParam g)) =
                              sval (sval (Yoneda10_Form_ee G' (g o>Generator_ param) (g o>GeneratorAtParam_ form)) G'' param' form'))
 (ee_ : forall (G : obGenerator) (param : Yoneda00_Param_F G) (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
        'CoMod ( View G ~> E @_ Yoneda10_Param_ee G param form @^ Yoneda10_Form_ee G param form )),
      grade ( [[  ee_  @_  param_ee0_ , isFiniteness_Param_F , Heq_param , Heq_param_ee , Yoneda10_Param_ee0_morphism  @^ isFiniteness_FormParam_F , Yoneda10_Form_ee_quotientLogical , Yoneda10_Form_ee_morphism  ]] )
      = (S (S ( (max (grade_param (param_ee0_(_)(Finiteness.param1 isFiniteness_Param_F)))%nat
                        (grade_param (param_ee0_(_)(Finiteness.param2 isFiniteness_Param_F)))%nat) +
                  (max
                    (max (grade (ee_( _ )( _ )(Finiteness.form1 isFiniteness_FormParam_F (Finiteness.param1 isFiniteness_Param_F))))
                         (grade (ee_( _ )( _ )(Finiteness.form2 isFiniteness_FormParam_F (Finiteness.param1 isFiniteness_Param_F)))))
                    (max (grade (ee_( _ )( _ )(Finiteness.form1 isFiniteness_FormParam_F (Finiteness.param2 isFiniteness_Param_F))))
                         (grade (ee_( _ )( _ )(Finiteness.form2 isFiniteness_FormParam_F (Finiteness.param2 isFiniteness_Param_F)))))))%nat)).
Proof. reflexivity. Qed.

Lemma grade_mut_Forget:
forall  ( Yoneda00_Form_F : obGenerator -> Type)
  (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F)
  (Yoneda00_Param_F : obGenerator -> Type)
  (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
  (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F)
  (F : obCoMod Yoneda10_FormParam_F)
  (Param_F : obCoMod_Param Yoneda01_Param_F)
  (Yoneda00_Param_SubstF : obGenerator -> Type)
  (Yoneda01_Param_SubstF : Yoneda01_data Yoneda00_Param_SubstF)
  (Param_SubstF : obCoMod_Param Yoneda01_Param_SubstF)
  (Yoneda10_Param_Forget : Yoneda10_data Yoneda01_Param_SubstF Yoneda01_Param_F)
  (param_Forget : 'CoMod_ ( Param_SubstF ~> Param_F @_ Yoneda10_Param_Forget ))
  (Yoneda10_Param_Forget' : {Yoneda10 : forall x : obGenerator, Yoneda00_Param_SubstF x -> Yoneda00_Param_F x | Yoneda10_natural Yoneda01_Param_SubstF Yoneda01_Param_F Yoneda10})
  (Heq_subst : forall (G : obGenerator) (param : Yoneda00_Param_SubstF G), sval Yoneda10_Param_Forget' G param = sval Yoneda10_Param_Forget G param)
  (Yoneda00_Form_E : obGenerator -> Type)
  (Yoneda01_Form_E : Yoneda01_data Yoneda00_Form_E)
  (Yoneda00_Param_E : obGenerator -> Type)
  (Yoneda01_Param_E : Yoneda01_data Yoneda00_Param_E)
  (Yoneda10_FormParam_E : Yoneda10_data Yoneda01_Form_E Yoneda01_Param_E)
  (E : obCoMod Yoneda10_FormParam_E)
  (Yoneda10_Param_ee : Yoneda10_data Yoneda01_Param_F Yoneda01_Param_E)
  (Yoneda10_Form_ee : Yoneda10_Form_data Yoneda10_FormParam_F Yoneda10_FormParam_E Yoneda10_Param_ee)
  (ee : 'CoMod ( F ~> E @_ Yoneda10_Param_ee @^ Yoneda10_Form_ee )),
    grade ('Forget @_ Heq_subst = param_Forget o>CoMod ee)
    = (S (S ( grade_param param_Forget + grade ee )%nat )).
Proof. reflexivity. Qed.

Lemma grade_mut_Remember:
forall (Yoneda00_Form_F : obGenerator -> Type)
 (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F)
 (Yoneda00_Param_F : obGenerator -> Type)
 (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
 (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F)
 (F : obCoMod Yoneda10_FormParam_F)
 (Param_F : obCoMod_Param Yoneda01_Param_F)
 (Yoneda00_Param_SubstF : obGenerator -> Type)
 (Yoneda01_Param_SubstF : Yoneda01_data Yoneda00_Param_SubstF)
 (Param_SubstF : obCoMod_Param Yoneda01_Param_SubstF),
 forall Yoneda10_Param_Forget (param_Forget : 'CoMod_( Param_SubstF ~> Param_F @_ Yoneda10_Param_Forget )),
 forall (L : obGenerator) Yoneda10_Param_ll Yoneda10_Form_ll
   (ll : 'CoMod( View L ~> F @_ Yoneda10_Param_ll @^ Yoneda10_Form_ll )),
 forall (**MEMO: when the generating parametrizator-functor is full then
      this polyelement is the same as one (decidable) single element [param : Yoneda01_Param_SubstF (Parameter0 L)] *)
   (Yoneda10_Param_ll_ : Yoneda10_data (Yoneda01_Param_View (Parameter0 L)) Yoneda01_Param_SubstF)
   (Heq_param : forall G param, sval Yoneda10_Param_ll G param
                           = sval (Yoneda10_Param_PolyCoMod Yoneda10_Param_ll_ Yoneda10_Param_Forget) G param),
 forall (Yoneda10_Param_Forget' : Yoneda10_data Yoneda01_Param_SubstF Yoneda01_Param_F)
   (Heq_subst : forall G param, sval Yoneda10_Param_Forget' G param = sval Yoneda10_Param_Forget G param),
  grade ( << ll @_ Heq_param = Yoneda10_Param_ll_ , Heq_subst = param_Forget >> )
    = (S (S ( (grade_param param_Forget )%nat + grade ll )%nat )).
Proof. reflexivity. Qed.

Lemma grade_mut_PolyCoMod_Param:
  forall (Yoneda00_Param_F : obGenerator -> Type) (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F) (Param_F : obCoMod_Param Yoneda01_Param_F) (Yoneda00_Param_F' : obGenerator -> Type)
    (Yoneda01_Param_F' : Yoneda01_data Yoneda00_Param_F') (Param_F' : obCoMod_Param Yoneda01_Param_F') (Yoneda10_Param_ff' : Yoneda10_data Yoneda01_Param_F' Yoneda01_Param_F),
  forall (param_ff' : 'CoMod_( Param_F' ~> Param_F @_ Yoneda10_Param_ff' )),
  forall (Yoneda00_Param_F'' : obGenerator -> Type) (Yoneda01_Param_F'' : Yoneda01_data Yoneda00_Param_F'') (Param_F'' : obCoMod_Param Yoneda01_Param_F'')
    (Yoneda10_Param_ff_ : Yoneda10_data Yoneda01_Param_F'' Yoneda01_Param_F'),
  forall (param_ff_ : 'CoMod_( Param_F'' ~> Param_F' @_ Yoneda10_Param_ff_ )),
    grade_param (param_ff_ o>CoMod_ param_ff') = ( 2 * (S (grade_param param_ff' + grade_param param_ff_)%nat ) )%nat .
Proof. reflexivity. Qed.

Lemma grade_mut_UnitCoMod_Param:
  forall (Yoneda00_Param_F : obGenerator -> Type) (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F),
  forall (Param_F : obCoMod_Param Yoneda01_Param_F),
    grade_param (@'UnitCoMod_ Param_F) =  (S ( O )).
Proof. reflexivity. Qed.

Lemma grade_mut_View1_Param:
  forall (G : obGenerator) (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P) (Q : obParametrizator) (p : 'Parametrizator( P ~> Q )),
      grade_param ('View1_ is_Parameter0_P p) =  (S O).
Proof. reflexivity. Qed.

Lemma grade_mut_ViewedFunctor1_Param_default:
  forall (Yoneda00_Param_F : obGenerator -> Type) (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F) (Param_F : obCoMod_Param Yoneda01_Param_F) (Yoneda00_Param_E : obGenerator -> Type)
    (Yoneda01_Param_E : Yoneda01_data Yoneda00_Param_E) (Param_E : obCoMod_Param Yoneda01_Param_E) (Yoneda10_Param_ff : Yoneda10_data Yoneda01_Param_E Yoneda01_Param_F),
  forall (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff )),
    grade_param ( 'ViewedFunctor1_ param_ff ) = (S (grade_param param_ff)%nat).
Proof. reflexivity. Qed.

Lemma grade_mut_UnitViewedFunctor_Param_default:
  forall (Yoneda00_Param_F : obGenerator -> Type) (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F) (Param_F : obCoMod_Param Yoneda01_Param_F) (Yoneda00_Param_E : obGenerator -> Type)
    (Yoneda01_Param_E : Yoneda01_data Yoneda00_Param_E) (Param_E : obCoMod_Param Yoneda01_Param_E) (Yoneda10_Param_ff : Yoneda10_data Yoneda01_Param_E Yoneda01_Param_F),
  forall (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff )),
    grade_param ( param_ff o>CoMod_ 'UnitViewedFunctor_ ) = (S (grade_param param_ff)%nat).
Proof. reflexivity. Qed.

Lemma grade_mut_PolyElement_Param_default:
  forall (Yoneda00_Param_F : obGenerator -> Type) (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
      (isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F)
    (Yoneda10_Param_param_ : forall G : obGenerator, Yoneda00_Param_F G -> forall P : obParametrizator, is_Parameter0 G P -> Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_F)
  (Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G) (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
              param = sval (Yoneda10_Param_param_ G param P is_Parameter0_P) G (is_Parameter0_transp_rev_codom is_Parameter0_P unitParametrizator))
  Yoneda10_Param_param_morphism,
  forall G : obGenerator, forall (param : Yoneda00_Param_F G) (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
    grade_param ( 'PolyElement_ param @_ isFiniteness_Param_F , is_Parameter0_P , Heq_param , Yoneda10_Param_param_morphism ) = (S (S O)) .
Proof. reflexivity. Qed.

Lemma grade_mut_PolyTransf_Param_default:
  forall (Yoneda00_Param_F : obGenerator -> Type) (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
  (isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F),
  forall (Yoneda10_Param_param_ : forall G : obGenerator, Yoneda00_Param_F G -> forall P : obParametrizator, is_Parameter0 G P -> Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_F)
    (Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G) (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
              param = sval (Yoneda10_Param_param_ G param P is_Parameter0_P) G (is_Parameter0_transp_rev_codom is_Parameter0_P unitParametrizator))
    (Yoneda00_Param_E : obGenerator -> Type)
    (Yoneda01_Param_E : Yoneda01_data Yoneda00_Param_E)
    (Param_E : obCoMod_Param Yoneda01_Param_E)
    (Yoneda10_Param_ee : forall G : obGenerator, Yoneda00_Param_F G -> forall P : obParametrizator, is_Parameter0 G P -> Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_E)
    Yoneda10_Param_ee_morphism
    (param_ee_ : forall (G : obGenerator) (param : Yoneda00_Param_F G) (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
              'CoMod_ ( View_Param P ~> Param_E @_ Yoneda10_Param_ee G param P is_Parameter0_P )),
      grade_param ( [[_ param_ee_ @_ isFiniteness_Param_F , Heq_param , Yoneda10_Param_ee_morphism ]] )
      = (S (S (
                    (max (grade_param (param_ee_( _ )(Finiteness.param1 isFiniteness_Param_F)(_)(Is_Parameter0 _)))
                         (grade_param (param_ee_( _ )(Finiteness.param2 isFiniteness_Param_F)(_)(Is_Parameter0 _))))))).
Proof. reflexivity. Qed.

Lemma grade_mut_Formatting:
    forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
      (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E)
      (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
    forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
      (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F)
      (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda10_Param_ff0
      (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff0 )),
    forall Yoneda10_Param_ff Yoneda10_Form_ff
      (ff : 'CoMod( E ~> F @_  Yoneda10_Param_ff @^ Yoneda10_Form_ff )),
    grade_param ('Formatting ff @_ param_ff) = (S ( grade_param param_ff + grade ff )%nat ).
Proof. reflexivity. Qed.

Definition grade_rewrite :=
  (grade_mut_PolyCoMod, grade_mut_UnitCoMod,
   grade_mut_View1, grade_mut_PolyElement_default, grade_mut_PolyTransf_default,
   grade_mut_Forget, grade_mut_Remember, grade_mut_PolyCoMod_Param, grade_mut_UnitCoMod_Param,
   grade_mut_View1_Param , grade_mut_UnitViewedFunctor , grade_mut_ViewedFunctor1 ,
   grade_mut_ViewedFunctor1_Param_default , grade_mut_UnitViewedFunctor_Param_default ,
   grade_mut_PolyElement_Param_default, grade_mut_PolyTransf_Param_default, grade_mut_Formatting ).

Lemma grade_mut_gt0 :
  ( forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
      (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E),
    forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
      (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F),
    forall Yoneda10_Param_ff Yoneda10_Form_ff (ff : 'CoMod( E ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff )),
      ((S O) <= (grade ff))%nat ) *
( forall Yoneda00_Param_E Yoneda01_Param_E (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
    forall Yoneda00_Param_F Yoneda01_Param_F (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda10_Param_ff (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff )),
      ((S O) <= (grade_param param_ff))%nat )%type .
Proof.
  apply: morCoMod_morCoMod_Param_mutind;
    intros; rewrite ?grade_rewrite; intros; abstract Lia.lia.
Qed.

Definition grade_gt0 := fst grade_mut_gt0.
Definition grade_param_gt0 := snd grade_mut_gt0.

Ltac tac_grade_gt0 :=
  match goal with
  | [ gg1 : 'CoMod( _ ~> _ @_ _ @^ _ ) ,
            gg2 : 'CoMod( _ ~> _ @_ _ @^ _ ) ,
                  gg3 : 'CoMod( _ ~> _ @_ _ @^ _ ) ,
                        gg4 : 'CoMod( _ ~> _ @_ _ @^ _ ) |- _ ] =>
    move : (@grade_gt0 _ _ _ _ _ _ _ _ _ _ _ _ _ _ gg1) (@grade_gt0 _ _ _ _ _ _ _ _ _ _ _ _ _ _ gg2)
                                          (@grade_gt0 _ _ _ _ _ _ _ _ _ _ _ _ _ _ gg3)
                                          (@grade_gt0 _ _ _ _ _ _ _ _ _ _ _ _ _ _ gg4)
  | [ gg1 : 'CoMod( _ ~> _ @_ _ @^ _ ) ,
            gg2 : 'CoMod( _ ~> _ @_ _ @^ _ ) ,
                  gg3 : 'CoMod( _ ~> _ @_ _ @^ _ ) |- _ ] =>
    move : (@grade_gt0 _ _ _ _ _ _ _ _ _ _ _ _ _ _ gg1) (@grade_gt0 _ _ _ _ _ _ _ _ _ _ _ _ _ _ gg2)
                                          (@grade_gt0 _ _ _ _ _ _ _ _ _ _ _ _ _ _ gg3)
  | [ gg1 : 'CoMod( _ ~> _ @_ _ @^ _ ) ,
            gg2 : 'CoMod( _ ~> _ @_ _ @^ _ )  |- _ ] =>
    move : (@grade_gt0 _ _ _ _ _ _ _ _ _ _ _ _ _ _ gg1) (@grade_gt0 _ _ _ _ _ _ _ _ _ _ _ _ _ _ gg2)
  | [ gg1 : 'CoMod( _ ~> _ @_ _ @^ _ )  |- _ ] =>
    move : (@grade_gt0 _ _ _ _ _ _ _ _ _ _ _ _ _ _ gg1)
  end.

Ltac tac_grade_param_gt0 :=
  match goal with
  | [ gg1 : 'CoMod_( _ ~> _ @_ _ ) ,
            gg2 : 'CoMod_( _ ~> _ @_ _ ) ,
                  gg3 : 'CoMod_( _ ~> _ @_ _ ) ,
                        gg4 : 'CoMod_( _ ~> _ @_ _ ) |- _ ] =>
    move : (@grade_param_gt0 _ _ _ _ _ _ _ gg1)
             (@grade_param_gt0 _ _ _ _ _ _ _ gg2)
             (@grade_param_gt0 _ _ _ _ _ _ _ gg3)
             (@grade_param_gt0 _ _ _ _ _ _ _ gg4)
  | [ gg1 : 'CoMod_( _ ~> _ @_ _ ) ,
            gg2 : 'CoMod_( _ ~> _ @_ _ ) ,
                  gg3 : 'CoMod_( _ ~> _ @_ _ ) |- _ ] =>
    move : (@grade_param_gt0 _ _ _ _ _ _ _ gg1)
             (@grade_param_gt0 _ _ _ _ _ _ _ gg2)
             (@grade_param_gt0 _ _ _ _ _ _ _ gg3)
  | [ gg1 : 'CoMod_( _ ~> _ @_ _ ) ,
            gg2 : 'CoMod_( _ ~> _ @_ _ )  |- _ ] =>
    move : (@grade_param_gt0 _ _ _ _ _ _ _ gg1)
             (@grade_param_gt0 _ _ _ _ _ _ _ gg2)
  | [ gg1 : 'CoMod_( _ ~> _ @_ _ )  |- _ ] =>
    move : (@grade_param_gt0 _ _ _ _ _ _ _ gg1)
  end.

Ltac tac_grade_gt0_parametric :=
match goal with
| [ isFiniteness_Param_F : Finiteness.isFiniteness_Param_ ?Yoneda01_Param_F,
    isFiniteness_FormParam_F : Finiteness.isFiniteness_FormParam_ ?Yoneda10_FormParam_F,
    gg1 : (forall (G : obGenerator) (param : _ (* ?Yoneda00_Param_F *) G)
             (form : @Yoneda00_AtParam_  _ _ _ _ _ (* ?Yoneda01_Param_F ?Yoneda10_FormParam_F *) _ param),
              'CoMod( _ ~> _ @_ _ @^ _ )),
    gg2 : (forall (G : obGenerator) (param : _ G)
             (form : @Yoneda00_AtParam_ _ _ _ _ _ _ param),
              'CoMod( _ ~> _ @_ _ @^ _ ))
    |- _ ] => move:
              (@grade_gt0 _ _ _ _ _ _ _ _ _ _ _ _ _ _
                          (@gg1 ( _ )( _ )(Finiteness.form1 isFiniteness_FormParam_F (Finiteness.param1 isFiniteness_Param_F))))
              (@grade_gt0 _ _ _ _ _ _ _ _ _ _ _ _ _ _
                          (@gg1 ( _ )( _ )(Finiteness.form2 isFiniteness_FormParam_F (Finiteness.param1 isFiniteness_Param_F))))
              (@grade_gt0 _ _ _ _ _ _ _ _ _ _ _ _ _ _
                          (@gg1 ( _ )( _ )(Finiteness.form1 isFiniteness_FormParam_F (Finiteness.param2 isFiniteness_Param_F))))
              (@grade_gt0 _ _ _ _ _ _ _ _ _ _ _ _ _ _
                          (@gg1 ( _ )( _ )(Finiteness.form2 isFiniteness_FormParam_F (Finiteness.param2 isFiniteness_Param_F))))
              (@grade_gt0 _ _ _ _ _ _ _ _ _ _ _ _ _ _
                          (@gg2 ( _ )( _ )(Finiteness.form1 isFiniteness_FormParam_F (Finiteness.param1 isFiniteness_Param_F))))
              (@grade_gt0 _ _ _ _ _ _ _ _ _ _ _ _ _ _
                          (@gg2 ( _ )( _ )(Finiteness.form2 isFiniteness_FormParam_F (Finiteness.param1 isFiniteness_Param_F))))
              (@grade_gt0 _ _ _ _ _ _ _ _ _ _ _ _ _ _
                          (@gg2 ( _ )( _ )(Finiteness.form1 isFiniteness_FormParam_F (Finiteness.param2 isFiniteness_Param_F))))
              (@grade_gt0 _ _ _ _ _ _ _ _ _ _ _ _ _ _
                          (@gg2 ( _ )( _ )(Finiteness.form2 isFiniteness_FormParam_F (Finiteness.param2 isFiniteness_Param_F))))
| [ isFiniteness_Param_F : Finiteness.isFiniteness_Param_ ?Yoneda01_Param_F,
    isFiniteness_FormParam_F : Finiteness.isFiniteness_FormParam_ ?Yoneda10_FormParam_F,
    gg1 : (forall (G : obGenerator) (param : _ (* ?Yoneda00_Param_F *) G)
             (form : @Yoneda00_AtParam_  _ _ _ _ _ (* ?Yoneda01_Param_F ?Yoneda10_FormParam_F *) _ param),
              'CoMod( _ ~> _ @_ _ @^ _ ))
    |- _ ] => move:
              (@grade_gt0 _ _ _ _ _ _ _ _ _ _ _ _ _ _
                          (@gg1 ( _ )( _ )(Finiteness.form1 isFiniteness_FormParam_F (Finiteness.param1 isFiniteness_Param_F))))
              (@grade_gt0 _ _ _ _ _ _ _ _ _ _ _ _ _ _
                          (@gg1 ( _ )( _ )(Finiteness.form2 isFiniteness_FormParam_F (Finiteness.param1 isFiniteness_Param_F))))
              (@grade_gt0 _ _ _ _ _ _ _ _ _ _ _ _ _ _
                          (@gg1 ( _ )( _ )(Finiteness.form1 isFiniteness_FormParam_F (Finiteness.param2 isFiniteness_Param_F))))
              (@grade_gt0 _ _ _ _ _ _ _ _ _ _ _ _ _ _
                          (@gg1 ( _ )( _ )(Finiteness.form2 isFiniteness_FormParam_F (Finiteness.param2 isFiniteness_Param_F))))
end.

Ltac tac_grade_param_gt0_parametric :=
match goal with
| [ isFiniteness_Param_F : Finiteness.isFiniteness_Param_ ?Yoneda01_Param_F,
    gg1 : (forall (G : obGenerator) (param : _ (* ?Yoneda00_Param_F *) G)
             (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
             'CoMod_( _ ~> _ @_ _ )),
    gg2 : (forall (G : obGenerator) (param : _ G)
             (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
              'CoMod_( _ ~> _ @_ _ ))
    |- _ ] => move:
              (@grade_param_gt0 _ _ _ _ _ _ _
                          (@gg1 ( _ )(Finiteness.param1 isFiniteness_Param_F)(_)(Is_Parameter0 _)))
              (@grade_param_gt0 _ _ _ _ _ _ _
                          (@gg1 ( _ )(Finiteness.param2 isFiniteness_Param_F)(_)(Is_Parameter0 _)))
              (@grade_param_gt0 _ _ _ _ _ _ _
                          (@gg2 ( _ )(Finiteness.param1 isFiniteness_Param_F)(_)(Is_Parameter0 _)))
              (@grade_param_gt0 _ _ _ _ _ _ _
                          (@gg2 ( _ )(Finiteness.param2 isFiniteness_Param_F)(_)(Is_Parameter0 _)))
| [ isFiniteness_Param_F : Finiteness.isFiniteness_Param_ ?Yoneda01_Param_F,
    gg1 : (forall (G : obGenerator) (param : _ G)
              (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
              'CoMod_( _ ~> _ @_ _ ))
    |- _ ] => move:
              (@grade_param_gt0 _ _ _ _ _ _ _
                          (@gg1 ( _ )(Finiteness.param1 isFiniteness_Param_F)(_)(Is_Parameter0 _)))
              (@grade_param_gt0 _ _ _ _ _ _ _
                          (@gg1 ( _ )(Finiteness.param2 isFiniteness_Param_F)(_)(Is_Parameter0 _)))
end.

Ltac tac_param_all :=
  repeat match goal with
         (*MEMO: when viewing-data is non-default :
           another match shall be above here , for [PolyTransf_common_PolyElement] *)
         | [ isFiniteness_Param_F : Finiteness.isFiniteness_Param_ ?Yoneda01_Param_F ,
             isFiniteness_FormParam_F : Finiteness.isFiniteness_FormParam_ ?Yoneda10_FormParam_F ,
             form : Yoneda00_AtParam_ ?Yoneda10_FormParam_F ?param
             |- context [max _ _] ] =>
           destruct (Finiteness.is_viewingFunctorParamElement12_allP isFiniteness_Param_F param);
           destruct (Finiteness.is_viewingFunctorElement12_allP isFiniteness_FormParam_F form)
         | (*MEMO: after above match *)
         (**TODO: the NOOP head constant [Element_data] would be useful to match hypotheses such as
            [ param : Element_data Yoneda00_Param_F G ]  *)
         [ isFiniteness_Param_F : Finiteness.isFiniteness_Param_ ?Yoneda01_Param_F ,
           G : obGenerator,
           param : ?Yoneda00_Param_F ?G
             |- context [max _ _] ] =>
           destruct (Finiteness.is_viewingFunctorParamElement12_allP isFiniteness_Param_F (param : Yoneda00_Param_F G))
         | [ isFiniteness_Param_F : Finiteness.isFiniteness_Param_ ?Yoneda01_Param_F ,
             isFiniteness_FormParam_F : Finiteness.isFiniteness_FormParam_ ?Yoneda10_FormParam_F ,
             Hgrade : (forall (G : obGenerator) (param : ?Yoneda00_Param_F G)
                         (form : Yoneda00_AtParam_ ?Yoneda10_FormParam_F param),
                          ( _ <= _ )%nat)
             |- context [max _ _] ] =>
           move: {Hgrade} (Hgrade ( _ )( _ )(Finiteness.form1 isFiniteness_FormParam_F (Finiteness.param1 isFiniteness_Param_F)))
                          (Hgrade ( _ )( _ )(Finiteness.form2 isFiniteness_FormParam_F (Finiteness.param1 isFiniteness_Param_F)))
                          (Hgrade ( _ )( _ )(Finiteness.form1 isFiniteness_FormParam_F (Finiteness.param2 isFiniteness_Param_F)))
                          (Hgrade ( _ )( _ )(Finiteness.form2 isFiniteness_FormParam_F (Finiteness.param2 isFiniteness_Param_F)));
           rewrite ?grade_rewrite
         | [ is_Parameter0_P : is_Parameter0 ?G ?P |- _ ] =>
           destruct is_Parameter0_P
         | [ isFiniteness_Param_F : Finiteness.isFiniteness_Param_ ?Yoneda01_Param_F ,
             Hgrade : (forall (G : obGenerator) (param : ?Yoneda00_Param_F G)
                         (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
                          ( _ <= _ )%nat)
             |- context [max _ _] ] =>
           move: {Hgrade} (Hgrade ( _ )(Finiteness.param1 isFiniteness_Param_F)(_)(Is_Parameter0 _))
                          (Hgrade ( _ )(Finiteness.param2 isFiniteness_Param_F)(_)(Is_Parameter0 _));
           rewrite ?grade_rewrite
         end.

Lemma degrade_mut :
  ( forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
      (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E),
    forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
      (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F),
    forall Yoneda10_Param_ff Yoneda10_Form_ff (ff : 'CoMod( E ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff )),
    forall Yoneda10_Param_ff0 Yoneda10_Form_ff0 (ff0 : 'CoMod( E ~> F @_ Yoneda10_Param_ff0 @^ Yoneda10_Form_ff0 )),
      ff0 <~~ ff -> ( grade ff0 <= grade ff )%nat ) /\
( forall Yoneda00_Param_E Yoneda01_Param_E (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
    forall Yoneda00_Param_F Yoneda01_Param_F (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda10_Param_ff (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff )),
    forall Yoneda10_Param_ff0 (param_ff0 : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff0 )),
      param_ff0 <~~_ param_ff -> ( grade_param param_ff0 <= grade_param param_ff )%nat ).
Proof.
  Time apply convCoMod_convCoMod_Param_mutind;
    try solve [intros; rewrite ?grade_rewrite;
                 try tac_grade_gt0; try tac_grade_param_gt0;
                   try tac_grade_gt0_parametric; try tac_grade_param_gt0_parametric;
                     tac_param_all;
                     simpl; intros; abstract Lia.lia].
Qed. (* /!\ LONG TIME 4s , 7s , 8s , 12s , 27s , 20s , 25s , 22s , 33s , 23s , 28s , 24s , 27s , 32 , 28s , 42s , 51s , 59s , 63s , 63s , 79s , 64s , 57s , 54s , 55s , 65s *)

Definition degrade := proj1 degrade_mut.
Definition degrade_param := proj2 degrade_mut.
(** # #
#+END_SRC

* Solution morphisms

  As common, the polymorphism cut-constructor [PolyCoMod] [PolyCoMod_Param] is not part of the solution terminology .

** Solution morphisms without polymorphism

#+BEGIN_SRC coq :exports both :results silent # # **)
Module Sol.
Section Section1.
Declare Scope sol_scope. Delimit Scope sol_scope with sol.

Inductive morCoMod : forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
                       (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E),
    forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
      (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F),
    forall Yoneda10_Param_ff (Yoneda10_Form_ff : Yoneda10_Form_data Yoneda10_FormParam_E Yoneda10_FormParam_F Yoneda10_Param_ff), Type :=

| UnitCoMod : forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
                (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F),
    'CoMod( F ~> F @_ Yoneda10_UnitCoMod_Param Yoneda01_Param_F @^ Yoneda10_UnitCoMod Yoneda10_FormParam_F )

| View1 : forall (G H : obGenerator) (g : 'Generator( H ~> G )),
    'CoMod( View H ~> View G @_ Yoneda10_Param_View1 (Parameter1 g) @^ Yoneda10_Form_View1 g )

| ViewedFunctor1_default : forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
                             (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F)
                             (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
      (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E)
      (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
    forall Yoneda10_Param_ff0 (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff0 )),
    forall Yoneda10_Param_ff Yoneda10_Form_ff (ff : 'CoMod( E ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff ))
      (Heq_param :  forall G param, sval Yoneda10_Param_ff G param = sval Yoneda10_Param_ff0 G param),
      'CoMod( ViewedFunctor_default E Param_E ~> ViewedFunctor_default F Param_F
                                    @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff )

| UnitViewedFunctor_default : forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
                                (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F)
                                (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
      (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E),
    forall Yoneda10_Param_ff Yoneda10_Form_ff
      (ff : 'CoMod( E ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff )),
      'CoMod( E ~> ViewedFunctor_default F Param_F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff )

| PolyElement_default :
    forall Yoneda00_Form_F (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F) Yoneda00_Param_F (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)  (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F),
    forall (isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F)
      (isFiniteness_FormParam_F : Finiteness.isFiniteness_FormParam_ Yoneda10_FormParam_F),
    forall (Yoneda10_Param_param_ : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F )
      (Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          (**MEMO: when the parametrization-functor is not full functor ,
             then [Yoneda10_Param_param_ G param] is more data than [param : Yoneda00_Param_F G] ... *)
          param = sval (Yoneda10_Param_param_ G param) G (@unitParametrizator (Parameter0 G)) ),
    forall (Yoneda10_Param_param_morphism : (**TODO: reverse equality ? *)
         forall G (param : Yoneda00_Param_F G),
         forall (param_ : Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F )
           (Heq_param :  param = sval param_ G (@unitParametrizator (Parameter0 G)) ),
         forall G' (param' : Yoneda00_Param_View (Parameter0 G) G')
           G'' (param'' : Yoneda00_Param_View (Parameter0 G') G''),
           sval (Yoneda10_Param_param_ G param) G'' (param'' o>Parametrizator param') =
           sval (Yoneda10_Param_param_ G' (sval param_ G' param')) G'' param''),
     forall (G : obGenerator) (param : Yoneda00_Param_F G) (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
        'CoMod( View G ~> ViewingFunctor_default isFiniteness_Param_F isFiniteness_FormParam_F  @_ Yoneda10_Param_param_ G param
                   @^ Yoneda10_Form_PolyElement_default Heq_param form)

| PolyTransf_default :
    forall Yoneda00_Form_F (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F) Yoneda00_Param_F (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)  (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F),
    forall (isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F)
      (isFiniteness_FormParam_F : Finiteness.isFiniteness_FormParam_ Yoneda10_FormParam_F),
    forall (Yoneda10_Param_param_ : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F )
      (Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          param = sval (Yoneda10_Param_param_ G param) G (@unitParametrizator (Parameter0 G)) ),
    forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
      (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E)
      (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
    forall (Yoneda10_Param_ee0 : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_E)
      (param_ee0_ : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          'CoMod_( View_Param (Parameter0 G) ~> Param_E
                       @_ (Yoneda10_Param_ee0 G param) )),
    forall  (Yoneda10_Param_ee : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                            (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
           Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_E)
       (Yoneda10_Form_ee : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                            (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
          Yoneda10_Form_data (Yoneda10_FormParam_View G) Yoneda10_FormParam_E (Yoneda10_Param_ee G param form))
       (Heq_param_ee : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                            (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
           forall G' param', sval (Yoneda10_Param_ee G param form) G' param' = sval (Yoneda10_Param_ee0 G param) G' param')
       (Yoneda10_Param_ee0_morphism : (**TODO: reverse equality ? *)
          forall G (param : Yoneda00_Param_F G),
          forall (param_ : Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F )
            (Heq_param :  param = sval param_ G (@unitParametrizator (Parameter0 G)) ),
          forall G'  (param' : Yoneda00_Param_View (Parameter0 G) G')
            G'' (param'' : Yoneda00_Param_View (Parameter0 G') G''),
            sval (Yoneda10_Param_ee0 G param) G'' (param'' o>Parametrizator param') =
            sval (Yoneda10_Param_ee0 G' (sval param_ G' param')) G'' param'')
       (Yoneda10_Form_ee_quotientLogical :
         forall G param form param' form', sval form = sval form' -> forall G0 param0 form0,
             sval (sval (Yoneda10_Form_ee G param form) G0 param0 form0)
             = sval (sval (Yoneda10_Form_ee G param' form')  G0 param0 form0))
      (Yoneda10_Form_ee_morphism :
         forall (G G' : obGenerator) (g : 'Generator( G' ~> G )) (param : Yoneda00_Param_F G)
           (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
         forall (G'' : obGenerator) (param' : (Yoneda00_Param_View (Parameter0 G')) G'')
           (form' : Yoneda00_AtParam_ (Yoneda10_FormParam_View G') param'),
           sval (sval (Yoneda10_Form_ee G param form)
                      G'' (param' o>Parametrizator (Parameter1 g))
                      (form' o>GeneratorAtParam g))
           = sval (sval (Yoneda10_Form_ee G' (g o>Generator_[sval Yoneda01_Param_F] param)
                                          (g o>GeneratorAtParam_[sval (Yoneda01_AtParam_(Yoneda10_FormParam_F))] form))
                         G'' param' form'))
      (ee_ : forall (G : obGenerator) (param : Yoneda00_Param_F G)
              (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
          'CoMod( View G ~> E
                       @_ (Yoneda10_Param_ee G param form) @^ (Yoneda10_Form_ee G param form))),

      'CoMod( ViewingFunctor_default isFiniteness_Param_F isFiniteness_FormParam_F ~> ViewedFunctor_default E Param_E
                                     @_ (Yoneda10_Param_PolyTransf_default Heq_param Yoneda10_Param_ee0_morphism)
                                     @^ (Yoneda10_Form_PolyTransf_default Heq_param Yoneda10_Param_ee0_morphism Heq_param_ee Yoneda10_Form_ee_quotientLogical Yoneda10_Form_ee_morphism) )

(**TODO: common-colimiting when into viewed-functor , but not now for this default viewing-data
   | PolyTransf_default_common :
   | PolyTransf_Param_default_common :   **)

| Forget :
 forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
   (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F)
   (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
 forall Yoneda00_Param_SubstF Yoneda01_Param_SubstF
   (Param_SubstF : @obCoMod_Param Yoneda00_Param_SubstF Yoneda01_Param_SubstF),
 forall Yoneda10_Param_Forget (param_Forget : 'CoMod_( Param_SubstF ~> Param_F @_ Yoneda10_Param_Forget )),
 forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
   (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E),
 forall Yoneda10_Param_ee Yoneda10_Form_ee
   (ee : 'CoMod( F ~> E @_ Yoneda10_Param_ee @^ Yoneda10_Form_ee )),
 forall (Yoneda10_Param_Forget' : Yoneda10_data Yoneda01_Param_SubstF Yoneda01_Param_F)
   (Heq_subst : forall G param, sval Yoneda10_Param_Forget' G param = sval Yoneda10_Param_Forget G param),
   'CoMod( Subst F Param_F Param_SubstF Yoneda10_Param_Forget' ~> E
                 @_ (Yoneda10_Param_PolyCoMod Yoneda10_Param_Forget Yoneda10_Param_ee)
                 @^ (Yoneda10_Form_PolyCoMod Yoneda10_Form_ee
                                             (Yoneda10_Form_Forget Yoneda10_FormParam_F Heq_subst)) )

| Remember :
 forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
   (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F)
   (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
 forall Yoneda00_Param_SubstF Yoneda01_Param_SubstF
   (Param_SubstF : @obCoMod_Param Yoneda00_Param_SubstF Yoneda01_Param_SubstF),
 forall Yoneda10_Param_Forget (param_Forget : 'CoMod_( Param_SubstF ~> Param_F @_ Yoneda10_Param_Forget )),
 forall (L : obGenerator) Yoneda10_Param_ll Yoneda10_Form_ll
   (ll : 'CoMod( View L ~> F @_ Yoneda10_Param_ll @^ Yoneda10_Form_ll )),
 forall (**MEMO: when the generating parametrizator-functor is full then
      this polyelement is the same as one (decidable) single element [param : Yoneda01_Param_SubstF (Parameter0 L)] *)
   (Yoneda10_Param_ll_ : Yoneda10_data (Yoneda01_Param_View (Parameter0 L)) Yoneda01_Param_SubstF)
   (Heq_param : forall G param, sval Yoneda10_Param_ll G param
                           = sval (Yoneda10_Param_PolyCoMod Yoneda10_Param_ll_ Yoneda10_Param_Forget) G param),
 forall (Yoneda10_Param_Forget' : Yoneda10_data Yoneda01_Param_SubstF Yoneda01_Param_F)
   (Heq_subst : forall G param, sval Yoneda10_Param_Forget' G param = sval Yoneda10_Param_Forget G param),
   'CoMod( View L  ~> Subst F Param_F Param_SubstF Yoneda10_Param_Forget'
              @_ Yoneda10_Param_ll_ @^ Yoneda10_Form_Remember Heq_subst Yoneda10_Form_ll Heq_param )

where "''CoMod' ( F' ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff )" :=
        (@morCoMod _ _ _ _ _ F' _ _ _ _ _ F Yoneda10_Param_ff Yoneda10_Form_ff) : sol_scope

with morCoMod_Param : forall Yoneda00_Param_E Yoneda01_Param_E (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
 forall Yoneda00_Param_F Yoneda01_Param_F (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
 forall Yoneda10_Param_ff : Yoneda10_data Yoneda01_Param_E Yoneda01_Param_F, Type :=

| UnitCoMod_Param : forall Yoneda00_Param_F Yoneda01_Param_F (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    'CoMod_( Param_F ~> Param_F @_ Yoneda10_UnitCoMod_Param Yoneda01_Param_F )

| View1_Param : forall (G : obGenerator) (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
    forall (Q : obParametrizator) (p : 'Parametrizator( P ~> Q )),
      'CoMod_( View_Param P ~> View_Param Q @_ Yoneda10_Param_View1 p )

| ViewedFunctor1_Param_default : forall Yoneda00_Param_F Yoneda01_Param_F
                                   (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda00_Param_E Yoneda01_Param_E
      (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
    forall Yoneda10_Param_ff (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff )),
      'CoMod_( ViewedFunctor_Param_default Param_E ~> ViewedFunctor_Param_default Param_F
                                           @_ Yoneda10_Param_ff )

| UnitViewedFunctor_Param_default : forall Yoneda00_Param_F Yoneda01_Param_F
                                      (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda00_Param_E Yoneda01_Param_E
      (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
    forall Yoneda10_Param_ff (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff )),
      'CoMod_( Param_E ~> ViewedFunctor_Param_default Param_F @_ Yoneda10_Param_ff )

| PolyElement_Param_default :
    forall Yoneda00_Param_F (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F),
    forall (isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F),
    forall (Yoneda10_Param_param_ : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                                 (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_F )
      (Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                     (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          param = sval (Yoneda10_Param_param_ G param P is_Parameter0_P)
                       G (is_Parameter0_transp_rev_codom is_Parameter0_P (@unitParametrizator (Parameter0 G))) ),
    forall (Yoneda10_Param_param_morphism : (**TODO: reverse equality ? *)
         forall G (param : Yoneda00_Param_F G) (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
         forall (param_ : Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_F )
           (Heq_param :  param = sval param_ G (is_Parameter0_transp_rev_codom is_Parameter0_P (@unitParametrizator (Parameter0 G)))),
         forall G'  (param' : Yoneda00_Param_View P G')
           G'' (param'' : Yoneda00_Param_View (Parameter0 G') G''),
           sval (Yoneda10_Param_param_ G param P is_Parameter0_P) G'' (param'' o>Parametrizator param') =
           sval (Yoneda10_Param_param_ G' (sval param_ G' param') (Parameter0 G') (Is_Parameter0 G')) G'' param'') ,
    forall (G : obGenerator) (param : Yoneda00_Param_F G) (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
      'CoMod_( View_Param P ~> ViewingFunctor_Param_default isFiniteness_Param_F @_ Yoneda10_Param_param_ G param P is_Parameter0_P )

| PolyTransf_Param_default :
    forall Yoneda00_Param_F (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F),
    forall (isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F),
    forall (Yoneda10_Param_param_ : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                                 (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_F )
      (Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                     (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          param = sval (Yoneda10_Param_param_ G param P is_Parameter0_P)
                       G (is_Parameter0_transp_rev_codom is_Parameter0_P (@unitParametrizator (Parameter0 G))) ),
    forall Yoneda00_Param_E Yoneda01_Param_E
      (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
    forall (Yoneda10_Param_ee : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                             (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_E)
      (Yoneda10_Param_ee_morphism : (**TODO: reverse equality ? *)
         forall G (param : Yoneda00_Param_F G) (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
         forall (param_ : Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_F )
           (Heq_param :  param = sval param_ G (is_Parameter0_transp_rev_codom is_Parameter0_P (@unitParametrizator (Parameter0 G)))),
         forall G'  (param' : Yoneda00_Param_View P G')
           G'' (param'' : Yoneda00_Param_View (Parameter0 G') G''),
           sval (Yoneda10_Param_ee G param P is_Parameter0_P) G'' (param'' o>Parametrizator param') =
           sval (Yoneda10_Param_ee G' (sval param_ G' param') (Parameter0 G') (Is_Parameter0 G')) G'' param'')
      (param_ee_ : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                     (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
          'CoMod_( View_Param P ~> Param_E @_ (Yoneda10_Param_ee G param P is_Parameter0_P) )),
      'CoMod_( ViewingFunctor_Param_default isFiniteness_Param_F ~> ViewedFunctor_Param_default Param_E
                                     @_ Yoneda10_Param_PolyTransf_default_Param Heq_param Yoneda10_Param_ee_morphism )

| Formatting :
    forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
      (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E)
      (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
    forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
      (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F)
      (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda10_Param_ff0 (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff0 )),
    forall Yoneda10_Param_ff Yoneda10_Form_ff
      (ff : 'CoMod( E ~> F @_ (* Yoneda10_Param_project <o *) Yoneda10_Param_ff @^ Yoneda10_Form_ff )),
      'CoMod_( Format E Param_E ~> Format F Param_F @_ (Yoneda10_Param_Formatting Yoneda10_Form_ff) )

where "''CoMod_' ( F' ~> F @_ Yoneda10_Param_ff )" :=
        (@morCoMod_Param _ _ F' _ _ F Yoneda10_Param_ff) : sol_scope .
End Section1.

Module Export Ex_Notations.
Declare Scope sol_scope. Delimit Scope sol_scope with sol.

Notation "''CoMod' ( F' ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff )" :=
  (@morCoMod _ _ _ _ _ F' _ _ _ _ _ F Yoneda10_Param_ff Yoneda10_Form_ff) : sol_scope.

Notation "''CoMod' (  F'  ~>  F  )" := (@morCoMod _ _ _ _ _ F' _ _ _ _ _ F _ _)
       (at level 0, only parsing) : sol_scope.

Notation "''CoMod_' ( F' ~> F @_ Yoneda10_Param_ff )" :=
        (@morCoMod_Param _ _ F' _ _ F Yoneda10_Param_ff) : sol_scope .

Notation "''CoMod_' (  F'  ~>  F  )" := (@morCoMod_Param _ _ F' _ _ F _)
       (at level 0, only parsing) : sol_scope.

Notation "@ ''UnitCoMod_' Param_F" := (@UnitCoMod_Param _ _ Param_F)
                                 (at level 10, Param_F at next level, only parsing) : sol_scope.

Notation "''UnitCoMod_'" := (@UnitCoMod_Param _ _ _) (at level 0) : sol_scope.

Notation "''View1_' is_Parameter0_P p" := (@View1_Param _ _ is_Parameter0_P _ p)
                   (at level 10, is_Parameter0_P , p at next level) : sol_scope.

Notation "''ViewedFunctor1_' param_ff" := (@ViewedFunctor1_Param_default _ _ _ _ _ _ _ param_ff)
                   (at level 10, param_ff at next level) : sol_scope.

Notation "param_ff o>CoMod_ 'UnitViewedFunctor_" :=
  (@UnitViewedFunctor_Param_default  _ _ _ _ _ _ _ param_ff)
    (at level 4, right associativity) : sol_scope.

Notation "''PolyElement_' param @_ isFiniteness_Param_F , is_Parameter0_P , Heq_param , Yoneda10_Param_param_morphism"
  := (@PolyElement_Param_default _ _ isFiniteness_Param_F _ Heq_param Yoneda10_Param_param_morphism _ param _ is_Parameter0_P)
       (at level 10, param , isFiniteness_Param_F , is_Parameter0_P , Heq_param, Yoneda10_Param_param_morphism at next level) : sol_scope.

Notation "''PolyElement_' param @_ isFiniteness_Param_F"
  := (@PolyElement_Param_default _ _ isFiniteness_Param_F _ _ _ _ param _ _)
       (at level 10, param , isFiniteness_Param_F at next level) : sol_scope.

Notation "[[_  param_ee_  @_  isFiniteness_Param_F  ,  Heq_param , Yoneda10_Param_ee_morphism  ]]" :=
  (@PolyTransf_Param_default _ _ isFiniteness_Param_F _ Heq_param _ _ _ _ Yoneda10_Param_ee_morphism param_ee_ )
    (at level 0, param_ee_ , isFiniteness_Param_F , Heq_param , Yoneda10_Param_ee_morphism at level 10) : sol_scope.

Notation "[[_  param_ee_  @_  isFiniteness_Param_F  ]]" :=
  (@PolyTransf_Param_default _ _ isFiniteness_Param_F _ _ _ _ _ _ _ param_ee_ )
    (at level 0, param_ee_ , isFiniteness_Param_F at level 10) : sol_scope.

Notation "''Formatting' ff @_ param_ff" :=
  (@Formatting _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ param_ff _ _ ff)
    (at level 10, ff , param_ff at next level) : sol_scope.

Notation "@ ''UnitCoMod' F" := (@UnitCoMod _ _ _ _ _ F)
                                 (at level 10, F at next level, only parsing) : sol_scope.

Notation "''UnitCoMod'" := (@UnitCoMod _ _ _ _ _ _) (at level 0) : sol_scope.

Notation "''View1' g" := (@View1 _ _ g)
                   (at level 10, g at next level) : sol_scope.

Notation "''ViewedFunctor1' ff @_ Heq_param = param_ff" :=
  (@ViewedFunctor1_default _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ param_ff _ _ ff Heq_param)
    (at level 10, ff , Heq_param , param_ff at next level) : sol_scope.

Notation "''ViewedFunctor1' ff @_ param_ff" :=
  (@ViewedFunctor1_default _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ param_ff _ _ ff _)
    (at level 10, ff ,  param_ff at next level) : sol_scope.

Notation "ff o>CoMod 'UnitViewedFunctor @_ Param_F" :=
  (@UnitViewedFunctor_default _ _ _ _ _ _ Param_F _ _ _ _ _ _ _ _ ff)
    (at level 4,  right associativity) : sol_scope.

Notation "''PolyElement'  form  @_  isFiniteness_Param_F , Heq_param , Yoneda10_Param_param_morphism @^  isFiniteness_FormParam_F"
  := (@PolyElement_default _ _ _ _ _ isFiniteness_Param_F isFiniteness_FormParam_F _ Heq_param  Yoneda10_Param_param_morphism _ _ form)
       (at level 10, form , isFiniteness_Param_F , Heq_param , Yoneda10_Param_param_morphism , isFiniteness_FormParam_F at next level) : sol_scope.

Notation "''PolyElement'  form  @_ isFiniteness_Param_F @^  isFiniteness_FormParam_F"
  := (@PolyElement_default _ _ _ _ _ isFiniteness_Param_F isFiniteness_FormParam_F _ _ _ _ _ form)
       (at level 10, form , isFiniteness_Param_F, isFiniteness_FormParam_F at next level) : sol_scope.

Notation "[[  ee_  @_ param_ee0_ , isFiniteness_Param_F , Heq_param , Heq_param_ee , Yoneda10_Param_ee0_morphism  @^ isFiniteness_FormParam_F , Yoneda10_Form_ee_quotientLogical , Yoneda10_Form_ee_morphism  ]]" :=
  (@PolyTransf_default _ _ _ _ _ isFiniteness_Param_F isFiniteness_FormParam_F _ Heq_param _ _ _ _ _ _ _ _ param_ee0_ _ _ Heq_param_ee Yoneda10_Param_ee0_morphism Yoneda10_Form_ee_quotientLogical Yoneda10_Form_ee_morphism ee_)
    (at level 0 , ee_ , param_ee0_ , isFiniteness_Param_F , Heq_param , Heq_param_ee , Yoneda10_Param_ee0_morphism , isFiniteness_FormParam_F , Yoneda10_Form_ee_quotientLogical , Yoneda10_Form_ee_morphism at level 10) : sol_scope.

Notation "[[  ee_  @_ param_ee0_ , isFiniteness_Param_F @^  isFiniteness_FormParam_F  ]]" :=
  (@PolyTransf_default _ _ _ _ _ isFiniteness_Param_F isFiniteness_FormParam_F _ _ _ _ _ _ _ _ _ _ param_ee0_ _ _ _ _ _ _ ee_)
    (at level 0, ee_ , param_ee0_ , isFiniteness_Param_F , isFiniteness_FormParam_F at level 10) : sol_scope.

Notation "''Forget' @_ Heq_subst = param_Forget o>CoMod ee" :=
  (@Forget _ _ _ _ _ _ _ _ _ _ _ param_Forget _ _ _ _ _ _ _ _ ee _ Heq_subst)
    (at level 10, Heq_subst , param_Forget, ee at next level) : sol_scope.

Notation "''Forget' @_ param_Forget o>CoMod ee" :=
  (@Forget _ _ _ _ _ _ _ _ _ _ _ param_Forget _ _ _ _ _ _ _ _ ee _ _)
    (at level 10, param_Forget, ee at next level) : sol_scope.

Notation "<<  ll  @_  Heq_param  =  Yoneda10_Param_ll_  ,  Heq_subst = param_Forget  >>" :=
  (@Remember _ _ _ _ _ _ _ _ _ _ _ param_Forget _ _ _ ll Yoneda10_Param_ll_ Heq_param _ Heq_subst)
    (at level 0, ll, Heq_param , Yoneda10_Param_ll_ , Heq_subst , param_Forget at level 10) : sol_scope.

Notation "<<  ll  @_  Yoneda10_Param_ll_  ,  param_Forget  >>" :=
  (@Remember _ _ _ _ _ _ _ _ _ _ _ param_Forget _ _ _ ll Yoneda10_Param_ll_ _ _ _)
    (at level 0, ll, Yoneda10_Param_ll_ , param_Forget at level 10) : sol_scope.
End Ex_Notations.

Scheme morCoMod_morCoMod_Param_ind := Induction for morCoMod Sort Prop
 with  morCoMod_Param_morCoMod_ind := Induction for morCoMod_Param Sort Prop.
Combined Scheme morCoMod_morCoMod_Param_mutind from
         morCoMod_morCoMod_Param_ind, morCoMod_Param_morCoMod_ind.
Scheme  morCoMod_morCoMod_Param_rect := Induction for morCoMod Sort Type
 with  morCoMod_Param_morCoMod_rect := Induction for morCoMod_Param Sort Type.
Definition morCoMod_morCoMod_Param_mutrect P P0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 a13 a14 a15 :=
  pair (@morCoMod_morCoMod_Param_rect P P0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 a13 a14 a15 )
       (@morCoMod_Param_morCoMod_rect P P0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 a13 a14 a15 ).

Definition toPolyMor_mut :
  (forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
                        (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E),
    forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
      (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F),
    forall Yoneda10_Param_ff Yoneda10_Form_ff (ff : 'CoMod( E ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff ) %sol),
       'CoMod( E ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff ) %poly ) *
  (forall Yoneda00_Param_E Yoneda01_Param_E (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
    forall Yoneda00_Param_F Yoneda01_Param_F (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda10_Param_ff (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff ) %sol),
      'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff ) %poly ) .
Proof.
  apply: morCoMod_morCoMod_Param_mutrect.
  - (** UnitCoMod *) intros Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F F.
    exact: ( @'UnitCoMod F ) %poly.
  - (** View1 *) intros G H g.
    exact: ('View1 g) %poly.
  - (** ViewedFunctor1_default *) intros Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F F Param_F Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E E Param_E
                                        Yoneda10_Param_ff0 param_ff IH_param_ff Yoneda10_Param_ff Yoneda10_Form_ff ff IH_ff Heq_param.
    exact: ( 'ViewedFunctor1 IH_ff @_ Heq_param = IH_param_ff ) %poly.
  - (**  UnitViewedFunctor_default *) intros Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F F Param_F Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E E Yoneda10_Param_ff
                                            Yoneda10_Form_ff ff IH_ff.
    exact: ( IH_ff  o>CoMod 'UnitViewedFunctor @_ Param_F )%poly.
  - (** PolyElement_default *) intros Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F isFiniteness_Param_F isFiniteness_FormParam_F Yoneda10_Param_param_ Heq_param Yoneda10_Param_param_morphism G param form.
    exact: ( 'PolyElement form @_ isFiniteness_Param_F , Heq_param , Yoneda10_Param_param_morphism @^ isFiniteness_FormParam_F ) %poly.
  - (** PolyTransf_default *) intros Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F isFiniteness_Param_F isFiniteness_FormParam_F Yoneda10_Param_param_ Heq_param Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
                                    E Param_E Yoneda10_Param_ee0 param_ee0_ IH_param_ee0_ Yoneda10_Param_ee Yoneda10_Form_ee Heq_param_ee Yoneda10_Param_ee0_morphism Yoneda10_Form_ee_quotientLogical Yoneda10_Form_ee_morphism ee_ IH_ee_.
    exact: ( [[ IH_ee_ @_  IH_param_ee0_ , isFiniteness_Param_F , Heq_param , Heq_param_ee , Yoneda10_Param_ee0_morphism @^ isFiniteness_FormParam_F , Yoneda10_Form_ee_quotientLogical , Yoneda10_Form_ee_morphism ]] ) %poly  .
  - (** Forget *) intros Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F F Param_F Yoneda00_Param_SubstF Yoneda01_Param_SubstF Param_SubstF Yoneda10_Param_Forget param_Forget IH_param_Forget
                         Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E E Yoneda10_Param_ee Yoneda10_Form_ee ee IH_ee Yoneda10_Param_Forget' Heq_subst.
    exact: ('Forget @_ Heq_subst = IH_param_Forget o>CoMod IH_ee)%poly.
  - (** Remember *) intros Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F F Param_F Yoneda00_Param_SubstF Yoneda01_Param_SubstF Param_SubstF Yoneda10_Param_Forget param_Forget IH_param_Forget L
                          Yoneda10_Param_ll Yoneda10_Form_ll ll IH_ll Yoneda10_Param_ll_ Heq_param Yoneda10_Param_Forget' Heq_subst.
    exact: ( << IH_ll @_ Heq_param = Yoneda10_Param_ll_ , Heq_subst = IH_param_Forget >> )%poly .
  - (** UnitCoMod_Param *) intros Yoneda00_Param_F Yoneda01_Param_F Param_F.
    exact: (@'UnitCoMod_ Param_F)%poly.
  - (** View1_Param *) intros G P is_Parameter0_P Q p.
    exact: ('View1_ is_Parameter0_P p)%poly.
  - (** ViewedFunctor1_Param_default *) intros Yoneda00_Param_F Yoneda01_Param_F Param_F Yoneda00_Param_E Yoneda01_Param_E Param_E Yoneda10_Param_ff param_ff IH_param_ff.
    exact: ( 'ViewedFunctor1_ IH_param_ff )%poly.
  - (**  UnitViewedFunctor_Param_default *) intros Yoneda00_Param_F Yoneda01_Param_F Param_F Yoneda00_Param_E Yoneda01_Param_E Param_E Yoneda10_Param_ff param_ff IH_param_ff.
    exact: ( IH_param_ff o>CoMod_ 'UnitViewedFunctor_ )%poly.
  - (** PolyElement_Param_default *) intros Yoneda00_Param_F Yoneda01_Param_F isFiniteness_Param_F Yoneda10_Param_param_ Heq_param Yoneda10_Param_param_morphism G param P is_Parameter0_P.
    exact: ( 'PolyElement_ param @_ isFiniteness_Param_F , is_Parameter0_P, Heq_param , Yoneda10_Param_param_morphism )%poly.
  - (** PolyTransf_Param_default *) intros Yoneda00_Param_F Yoneda01_Param_F isFiniteness_Param_F Yoneda10_Param_param_ Heq_param Yoneda00_Param_E Yoneda01_Param_E Param_E Yoneda10_Param_ee Yoneda10_Param_ee_morphism param_ee_ IH_param_ee_.
    exact: ( [[_ IH_param_ee_ @_ isFiniteness_Param_F , Heq_param , Yoneda10_Param_ee_morphism ]] )%poly.
  - (** Formatting *) intros Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E E Param_E Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F F Param_F
                         Yoneda10_Param_ff0 param_ff IH_param_ff Yoneda10_Param_ff Yoneda10_Form_ff ff IH_ff.
    exact: ( 'Formatting IH_ff @_ IH_param_ff )%poly.
Defined.

Definition toPolyMor := fst toPolyMor_mut.
Definition toPolyMor_param := snd toPolyMor_mut.
Arguments toPolyMor : simpl nomatch.
Arguments toPolyMor_param : simpl nomatch.

Lemma toPolyMor_mut_UnitCoMod:
  forall (Yoneda00_Form_F : obGenerator -> Type) (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F) (Yoneda00_Param_F : obGenerator -> Type) (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
    (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F),
  forall (F : obCoMod Yoneda10_FormParam_F),
    toPolyMor (@'UnitCoMod F )%sol = (@'UnitCoMod F )%poly.
Proof. reflexivity. Qed.

Lemma toPolyMor_mut_View1:
  forall G H : obGenerator, forall (g : 'Generator( H ~> G )), toPolyMor ('View1 g)%sol = ('View1 g)%poly .
Proof. reflexivity. Qed.

Lemma toPolyMor_mut_ViewedFunctor1:
forall (Yoneda00_Form_F : obGenerator -> Type)
 (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F)
 (Yoneda00_Param_F : obGenerator -> Type)
 (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
 (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F)
 (F : obCoMod Yoneda10_FormParam_F)
 (Param_F : obCoMod_Param Yoneda01_Param_F)
 (Yoneda00_Form_E : obGenerator -> Type)
 (Yoneda01_Form_E : Yoneda01_data Yoneda00_Form_E)
 (Yoneda00_Param_E : obGenerator -> Type)
 (Yoneda01_Param_E : Yoneda01_data Yoneda00_Param_E)
 (Yoneda10_FormParam_E : Yoneda10_data Yoneda01_Form_E Yoneda01_Param_E)
 (E : obCoMod Yoneda10_FormParam_E)
 (Param_E : obCoMod_Param Yoneda01_Param_E)
 Yoneda10_Param_ff0 (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff0 )%sol)
 Yoneda10_Param_ff Yoneda10_Form_ff (ff : 'CoMod( E ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff ) %sol) Heq_param,
  toPolyMor ( 'ViewedFunctor1 ff @_ Heq_param =  param_ff )%sol
    = ( 'ViewedFunctor1 (toPolyMor ff) @_ Heq_param = (toPolyMor_param param_ff) )%poly.
Proof. reflexivity. Qed.

Lemma toPolyMor_mut_UnitViewedFunctor:
  forall (Yoneda00_Form_F : obGenerator -> Type) (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F) (Yoneda00_Param_F : obGenerator -> Type) (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
    (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F) (F : obCoMod Yoneda10_FormParam_F) (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F)  (Yoneda00_Form_E : obGenerator -> Type)
    (Yoneda01_Form_E : Yoneda01_data Yoneda00_Form_E) (Yoneda00_Param_E : obGenerator -> Type) (Yoneda01_Param_E : Yoneda01_data Yoneda00_Param_E)
    (Yoneda10_FormParam_E : Yoneda10_data Yoneda01_Form_E Yoneda01_Param_E) (E : obCoMod Yoneda10_FormParam_E)
    (Yoneda10_Param_ff : Yoneda10_data Yoneda01_Param_E Yoneda01_Param_F),
  forall Yoneda10_Form_ff : Yoneda10_Form_data Yoneda10_FormParam_E Yoneda10_FormParam_F Yoneda10_Param_ff,
  forall (ff : 'CoMod( E ~> F  @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff )%sol),
    toPolyMor ( ff  o>CoMod 'UnitViewedFunctor @_ Param_F)%sol
    =   ((toPolyMor ff)  o>CoMod 'UnitViewedFunctor @_ Param_F)%poly.
Proof. reflexivity. Qed.

Lemma toPolyMor_mut_PolyElement_default:
  forall (Yoneda00_Form_F : obGenerator -> Type) (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F) (Yoneda00_Param_F : obGenerator -> Type) (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
    (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F)
    (isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F)
    (isFiniteness_FormParam_F : Finiteness.isFiniteness_FormParam_ Yoneda10_FormParam_F)
 (Yoneda10_Param_param_ : forall G : obGenerator, Yoneda00_Param_F G -> Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F)
  (Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G), param = sval (Yoneda10_Param_param_ G param) G unitParametrizator)
  Yoneda10_Param_param_morphism  (G : obGenerator)
  (param : Yoneda00_Param_F G)
  (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
    toPolyMor ( 'PolyElement form @_ isFiniteness_Param_F , Heq_param , Yoneda10_Param_param_morphism @^ isFiniteness_FormParam_F )%sol
    = ( 'PolyElement form @_ isFiniteness_Param_F , Heq_param , Yoneda10_Param_param_morphism @^ isFiniteness_FormParam_F )%poly .
Proof. reflexivity. Qed.

Lemma toPolyMor_mut_PolyTransf_default:
  forall  (Yoneda00_Form_F : obGenerator -> Type)
 (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F)
 (Yoneda00_Param_F : obGenerator -> Type)
 (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
 (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F)
 (isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F)
 (isFiniteness_FormParam_F : Finiteness.isFiniteness_FormParam_ Yoneda10_FormParam_F)
 (Yoneda10_Param_param_ : forall G : obGenerator, Yoneda00_Param_F G -> Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F)
 (Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G), param = sval (Yoneda10_Param_param_ G param) G unitParametrizator)
 (Yoneda00_Form_E : obGenerator -> Type)
 (Yoneda01_Form_E : Yoneda01_data Yoneda00_Form_E)
 (Yoneda00_Param_E : obGenerator -> Type)
 (Yoneda01_Param_E : Yoneda01_data Yoneda00_Param_E)
 (Yoneda10_FormParam_E : Yoneda10_data Yoneda01_Form_E Yoneda01_Param_E)
 (E : obCoMod Yoneda10_FormParam_E)
 (Param_E : obCoMod_Param Yoneda01_Param_E)
(  Yoneda10_Param_ee0 : forall G : obGenerator, Yoneda00_Param_F G -> Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_E)
(  param_ee0_ : forall (G : obGenerator) (param : Yoneda00_Param_F G), 'CoMod_ ( View_Param (Parameter0 G) ~> Param_E @_ Yoneda10_Param_ee0 G param )%sol)
(  Yoneda10_Param_ee : forall (G : obGenerator) (param : Yoneda00_Param_F G), Yoneda00_AtParam_ Yoneda10_FormParam_F param -> Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_E)
(  Yoneda10_Form_ee : forall (G : obGenerator) (param : Yoneda00_Param_F G) (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
                     Yoneda10_Form_data (Yoneda10_FormParam_View G) Yoneda10_FormParam_E (Yoneda10_Param_ee G param form))
(  Heq_param_ee : forall (G : obGenerator) (param : Yoneda00_Param_F G) (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param) (G' : obGenerator) (param' : Yoneda00_Param_View (Parameter0 G) G'),
                 sval (Yoneda10_Param_ee G param form) G' param' = sval (Yoneda10_Param_ee0 G param) G' param')
  Yoneda10_Param_ee0_morphism Yoneda10_Form_ee_quotientLogical Yoneda10_Form_ee_morphism
 (ee_ : forall (G : obGenerator) (param : Yoneda00_Param_F G) (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
 'CoMod ( View G ~> E @_ Yoneda10_Param_ee G param form @^ Yoneda10_Form_ee G param form )%sol),

      toPolyMor ( [[ ee_ @_ param_ee0_ ,  isFiniteness_Param_F , Heq_param , Heq_param_ee , Yoneda10_Param_ee0_morphism @^ isFiniteness_FormParam_F , Yoneda10_Form_ee_quotientLogical , Yoneda10_Form_ee_morphism ]] %sol)
      = ( [[ (fun G param form => (toPolyMor (ee_(G)(param)(form)))) @_ (fun G param => (toPolyMor_param (param_ee0_(G)(param)))) ,  isFiniteness_Param_F , Heq_param , Heq_param_ee ,  Yoneda10_Param_ee0_morphism @^ isFiniteness_FormParam_F , Yoneda10_Form_ee_quotientLogical , Yoneda10_Form_ee_morphism ]] %poly) .
Proof. reflexivity. Qed.

Lemma toPolyMor_mut_Forget:
  forall    (Yoneda00_Form_F : obGenerator -> Type)
  (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F)
  (Yoneda00_Param_F : obGenerator -> Type)
  (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
  (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F)
  (F : obCoMod Yoneda10_FormParam_F)
  (Param_F : obCoMod_Param Yoneda01_Param_F)
  (Yoneda00_Param_SubstF : obGenerator -> Type)
  (Yoneda01_Param_SubstF : Yoneda01_data Yoneda00_Param_SubstF)
  (Param_SubstF : obCoMod_Param Yoneda01_Param_SubstF)
  (Yoneda10_Param_Forget : Yoneda10_data Yoneda01_Param_SubstF Yoneda01_Param_F)
  (param_Forget : 'CoMod_ ( Param_SubstF ~> Param_F @_ Yoneda10_Param_Forget )%sol)
  (Yoneda10_Param_Forget' : Yoneda10_data Yoneda01_Param_SubstF Yoneda01_Param_F)
  (Heq_subst : forall (G : obGenerator) (param : Yoneda00_Param_SubstF G), sval Yoneda10_Param_Forget' G param = sval Yoneda10_Param_Forget G param)
  (Yoneda00_Form_E : obGenerator -> Type)
  (Yoneda01_Form_E : Yoneda01_data Yoneda00_Form_E)
  (Yoneda00_Param_E : obGenerator -> Type)
  (Yoneda01_Param_E : Yoneda01_data Yoneda00_Param_E)
  (Yoneda10_FormParam_E : Yoneda10_data Yoneda01_Form_E Yoneda01_Param_E)
  (E : obCoMod Yoneda10_FormParam_E)
  (Yoneda10_Param_ee : Yoneda10_data Yoneda01_Param_F Yoneda01_Param_E)
  (Yoneda10_Form_ee : Yoneda10_Form_data Yoneda10_FormParam_F Yoneda10_FormParam_E Yoneda10_Param_ee)
  (ee : 'CoMod ( F ~> E @_ Yoneda10_Param_ee @^ Yoneda10_Form_ee )%sol),
    toPolyMor ('Forget @_ Heq_subst = param_Forget o>CoMod ee)%sol
    =  ('Forget @_ Heq_subst = (toPolyMor_param param_Forget) o>CoMod (toPolyMor ee))%poly.
Proof. reflexivity. Qed.

Lemma toPolyMor_mut_Remember:
 forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
   (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F)
   (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
 forall Yoneda00_Param_SubstF Yoneda01_Param_SubstF
   (Param_SubstF : @obCoMod_Param Yoneda00_Param_SubstF Yoneda01_Param_SubstF),
 forall Yoneda10_Param_Forget (param_Forget : 'CoMod_( Param_SubstF ~> Param_F @_ Yoneda10_Param_Forget ) %sol),
 forall (L : obGenerator) Yoneda10_Param_ll Yoneda10_Form_ll
   (ll : 'CoMod( View L ~> F @_ Yoneda10_Param_ll @^ Yoneda10_Form_ll ) %sol),
 forall (**MEMO: when the generating parametrizator-functor is full then
      this polyelement is the same as one (decidable) single element [param : Yoneda01_Param_SubstF (Parameter0 L)] *)
   (Yoneda10_Param_ll_ : Yoneda10_data (Yoneda01_Param_View (Parameter0 L)) Yoneda01_Param_SubstF)
   (Heq_param : forall G param, sval Yoneda10_Param_ll G param
                           = sval (Yoneda10_Param_PolyCoMod Yoneda10_Param_ll_ Yoneda10_Param_Forget) G param),
 forall (Yoneda10_Param_Forget' : Yoneda10_data Yoneda01_Param_SubstF Yoneda01_Param_F)
   (Heq_subst : forall G param, sval Yoneda10_Param_Forget' G param = sval Yoneda10_Param_Forget G param),
    toPolyMor ( << ll @_ Heq_param = Yoneda10_Param_ll_ , Heq_subst = param_Forget >> )%sol
    =  ( << (toPolyMor ll) @_ Heq_param = Yoneda10_Param_ll_ , Heq_subst = (toPolyMor_param param_Forget) >> )%poly.
Proof. reflexivity. Qed.

Lemma toPolyMor_mut_UnitCoMod_Param:
  forall (Yoneda00_Param_F : obGenerator -> Type) (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F),
  forall (Param_F : obCoMod_Param Yoneda01_Param_F),
    toPolyMor_param (@'UnitCoMod_ Param_F)%sol
    =  (@'UnitCoMod_ Param_F)%poly.
Proof. reflexivity. Qed.

Lemma toPolyMor_mut_View1_Param:
forall (G : obGenerator) (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
    forall (Q : obParametrizator) (p : 'Parametrizator( P ~> Q )),
    toPolyMor_param ('View1_ is_Parameter0_P p)%sol
    = ('View1_ is_Parameter0_P p)%poly.
Proof. reflexivity. Qed.

Lemma toPolyMor_mut_ViewedFunctor1_Param_default:
  forall (Yoneda00_Param_F : obGenerator -> Type) (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F) (Param_F : obCoMod_Param Yoneda01_Param_F) (Yoneda00_Param_E : obGenerator -> Type)
    (Yoneda01_Param_E : Yoneda01_data Yoneda00_Param_E) (Param_E : obCoMod_Param Yoneda01_Param_E) (Yoneda10_Param_ff : Yoneda10_data Yoneda01_Param_E Yoneda01_Param_F),
  forall (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff )%sol),
    toPolyMor_param ( 'ViewedFunctor1_ param_ff )%sol
    =    ( 'ViewedFunctor1_ (toPolyMor_param param_ff) )%poly.
Proof. reflexivity. Qed.

Lemma toPolyMor_mut_UnitViewedFunctor_Param_default:
  forall (Yoneda00_Param_F : obGenerator -> Type) (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F) (Param_F : obCoMod_Param Yoneda01_Param_F) (Yoneda00_Param_E : obGenerator -> Type)
    (Yoneda01_Param_E : Yoneda01_data Yoneda00_Param_E) (Param_E : obCoMod_Param Yoneda01_Param_E) (Yoneda10_Param_ff : Yoneda10_data Yoneda01_Param_E Yoneda01_Param_F),
  forall (param_ff : 'CoMod_( Param_E ~>  Param_F @_ Yoneda10_Param_ff )%sol),
    toPolyMor_param ( param_ff o>CoMod_ 'UnitViewedFunctor_ )%sol
    = ((toPolyMor_param  param_ff) o>CoMod_ 'UnitViewedFunctor_ )%poly.
Proof. reflexivity. Qed.

Lemma toPolyMor_mut_PolyElement_Param_default:
  forall (Yoneda00_Param_F : obGenerator -> Type)
    (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
    (isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F)
(  Yoneda10_Param_param_ : forall G : obGenerator, Yoneda00_Param_F G -> forall P : obParametrizator, is_Parameter0 G P -> Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_F)
(  Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G) (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
              param = sval (Yoneda10_Param_param_ G param P is_Parameter0_P) G (is_Parameter0_transp_rev_codom is_Parameter0_P unitParametrizator))
  Yoneda10_Param_param_morphism
(  G : obGenerator)
(  param : Yoneda00_Param_F G)
(  P : obParametrizator)
(  is_Parameter0_P : is_Parameter0 G P),
      toPolyMor_param ( 'PolyElement_ param @_ isFiniteness_Param_F , is_Parameter0_P , Heq_param , Yoneda10_Param_param_morphism )%sol
      = ( 'PolyElement_ param @_ isFiniteness_Param_F , is_Parameter0_P, Heq_param , Yoneda10_Param_param_morphism )%poly.
Proof. reflexivity. Qed.

Lemma toPolyMor_mut_PolyTransf_Param_default:
  forall (Yoneda00_Param_F : obGenerator -> Type) (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
      (isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F),
  forall (Yoneda10_Param_param_ : forall G : obGenerator, Yoneda00_Param_F G -> forall P : obParametrizator, is_Parameter0 G P -> Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_F)
(  Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G) (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
              param = sval (Yoneda10_Param_param_ G param P is_Parameter0_P) G (is_Parameter0_transp_rev_codom is_Parameter0_P unitParametrizator))
(  Yoneda00_Param_E : obGenerator -> Type)
(  Yoneda01_Param_E : Yoneda01_data Yoneda00_Param_E)
(  Param_E : obCoMod_Param Yoneda01_Param_E)
(  Yoneda10_Param_ee : forall G : obGenerator, Yoneda00_Param_F G -> forall P : obParametrizator, is_Parameter0 G P -> Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_E)
  Yoneda10_Param_ee_morphism
(  param_ee_ : forall (G : obGenerator) (param : Yoneda00_Param_F G) (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
              'CoMod_ ( View_Param P ~> Param_E @_ Yoneda10_Param_ee G param P is_Parameter0_P )%sol ),
      toPolyMor_param ( [[_ param_ee_ @_ isFiniteness_Param_F , Heq_param , Yoneda10_Param_ee_morphism ]] )%sol
=     ( [[_ (fun G param P is_Parameter0_P => (toPolyMor_param (param_ee_(G)(param)(P)(is_Parameter0_P)))) @_ isFiniteness_Param_F , Heq_param , Yoneda10_Param_ee_morphism ]] )%poly.
Proof. reflexivity. Qed.

Lemma toPolyMor_mut_Formatting:
    forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
      (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E)
      (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
    forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
      (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F)
      (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda10_Param_ff0
      (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff0 ) %sol),
    forall Yoneda10_Param_ff Yoneda10_Form_ff
      (ff : 'CoMod( E ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff ) %sol),
    toPolyMor_param ('Formatting ff @_ param_ff)%sol
    =  ( 'Formatting (toPolyMor ff) @_  (toPolyMor_param param_ff) )%poly.
Proof. reflexivity. Qed.

Definition toPolyMor_mut_rewrite :=
  (toPolyMor_mut_UnitCoMod,
   toPolyMor_mut_View1, toPolyMor_mut_PolyElement_default, toPolyMor_mut_PolyTransf_default,
   toPolyMor_mut_Forget, toPolyMor_mut_Remember, toPolyMor_mut_UnitCoMod_Param,
   toPolyMor_mut_View1_Param , toPolyMor_mut_UnitViewedFunctor , toPolyMor_mut_ViewedFunctor1 ,
   toPolyMor_mut_ViewedFunctor1_Param_default , toPolyMor_mut_UnitViewedFunctor_Param_default ,
   toPolyMor_mut_PolyElement_Param_default, toPolyMor_mut_PolyTransf_Param_default, toPolyMor_mut_Formatting ).
(** # #
#+END_SRC

** Destruction of morphisms with inner-instantiation of object-indexes

  As common , the polymorphism/cut-elimination resolution will require the destruction of some morphism which is constrained by the structure of its domain/codomain objects .

  Memo that in this ongoing COQ program for colimits ( and pi-substitution-objects , which are limits ) , oneself starts to general-destruct the postfix-parameter [f'] of the composition [(f_ o>CoMod f')] and then to constrained-destruct (filter the admissible inputs) the prefix-argument [f_] . This may be more sensible ...

#+BEGIN_SRC coq :exports both :results silent # # **)
Module Destruct_codomView.
Inductive morCoMod_codomView
: forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
    (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E),
    forall G : obGenerator, forall Yoneda10_Param_ff Yoneda10_Form_ff,
        'CoMod( E ~> View G @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff )%sol -> Type :=
| UnitCoMod :  forall G : obGenerator,
    morCoMod_codomView ( ( @'UnitCoMod (View G) )%sol )

|  View1 : forall (G H : obGenerator) (g : 'Generator( H ~> G )),
    morCoMod_codomView ( ( 'View1 g )%sol )
| Forget :  forall (Yoneda00_Form_F : obGenerator -> Type)
  (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F)
  (Yoneda00_Param_F : obGenerator -> Type)
  (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
  (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F)
  (F : obCoMod Yoneda10_FormParam_F)
  (Param_F : obCoMod_Param Yoneda01_Param_F)
  (Yoneda00_Param_SubstF : obGenerator -> Type)
  (Yoneda01_Param_SubstF : Yoneda01_data Yoneda00_Param_SubstF)
  (Param_SubstF : obCoMod_Param Yoneda01_Param_SubstF)
  (Yoneda10_Param_Forget : Yoneda10_data Yoneda01_Param_SubstF Yoneda01_Param_F)
  (param_Forget : 'CoMod_ ( Param_SubstF ~> Param_F @_ Yoneda10_Param_Forget )%sol)
  (Yoneda10_Param_Forget' : Yoneda10_data Yoneda01_Param_SubstF Yoneda01_Param_F)
  (Heq_subst : forall G param, sval Yoneda10_Param_Forget' G param = sval Yoneda10_Param_Forget G param)
  (G : obGenerator)
  (Yoneda10_Param_ee : Yoneda10_data Yoneda01_Param_F (Yoneda01_Param_View (Parameter0 G)))
  (Yoneda10_Form_ee : Yoneda10_Form_data Yoneda10_FormParam_F (Yoneda10_FormParam_View G) Yoneda10_Param_ee)
  (ff : 'CoMod ( F ~> View G @_ Yoneda10_Param_ee @^ Yoneda10_Form_ee )%sol),
  morCoMod_codomView ('Forget @_ Heq_subst = param_Forget o>CoMod ff)%sol.

Lemma morCoMod_codomViewP
  : forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
                        (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E),
    forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
      (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F),
    forall Yoneda10_Param_ff Yoneda10_Form_ff (ff : 'CoMod( E ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff ) %sol),
      ltac:( destruct F; [ | refine (unit : Type) .. ];
               refine (morCoMod_codomView ff) ).
Proof.
  intros. destruct ff.
  - destruct F; [ | intros; exact: tt .. ].
    constructor 1.
  - constructor 2.
  - intros; exact: tt.
  - intros; exact: tt.
  - intros; exact: tt.
  - intros; exact: tt.
  - intros. destruct E.
    + constructor 3.
    + intros; exact: tt.
    + intros; exact: tt.
    + intros; exact: tt.
  - intros; exact: tt.
Defined.
End Destruct_codomView.

Module Destruct_codomViewingFunctor.
Inductive morCoMod_codomViewingFunctor
  : forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
                        (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E),
    forall Yoneda00_Form_F (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F) Yoneda00_Param_F (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)  (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F) (isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F)
      (isFiniteness_FormParam_F : Finiteness.isFiniteness_FormParam_ Yoneda10_FormParam_F),
forall Yoneda10_Param_ff Yoneda10_Form_ff (ff : 'CoMod( E ~> ViewingFunctor_default isFiniteness_Param_F isFiniteness_FormParam_F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff ) %sol), Type :=
| UnitCoMod : forall (Yoneda00_Form_F : obGenerator -> Type)
  (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F)
  (Yoneda00_Param_F : obGenerator -> Type)
  (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
  (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F)
  (isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F)
  (isFiniteness_FormParam_F : Finiteness.isFiniteness_FormParam_ Yoneda10_FormParam_F),
    morCoMod_codomViewingFunctor (@'UnitCoMod (ViewingFunctor_default isFiniteness_Param_F isFiniteness_FormParam_F))%sol
| PolyElement_default : forall (Yoneda00_Form_F : obGenerator -> Type)
  (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F)
  (Yoneda00_Param_F : obGenerator -> Type)
  (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
  (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F)
  (isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F)
  (isFiniteness_FormParam_F : Finiteness.isFiniteness_FormParam_ Yoneda10_FormParam_F)
  (Yoneda10_Param_param_ : forall G : obGenerator, Yoneda00_Param_F G -> Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F)
  (Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G), param = sval (Yoneda10_Param_param_ G param) G unitParametrizator)
  Yoneda10_Param_param_morphism
  (G : obGenerator)
  (param : Yoneda00_Param_F G)
  (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
  morCoMod_codomViewingFunctor ('PolyElement form @_ isFiniteness_Param_F , Heq_param, Yoneda10_Param_param_morphism @^ isFiniteness_FormParam_F)%sol
| Forget : forall (Yoneda00_Form_F : obGenerator -> Type)
  (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F)
(  Yoneda00_Param_F : obGenerator -> Type)
(  Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
(  Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F)
(  F : obCoMod Yoneda10_FormParam_F)
(  Param_F : obCoMod_Param Yoneda01_Param_F)
(  Yoneda00_Param_SubstF : obGenerator -> Type)
(  Yoneda01_Param_SubstF : Yoneda01_data Yoneda00_Param_SubstF)
(  Param_SubstF : obCoMod_Param Yoneda01_Param_SubstF)
(  Yoneda10_Param_Forget : Yoneda10_data Yoneda01_Param_SubstF Yoneda01_Param_F)
(  param_Forget : 'CoMod_ ( Param_SubstF ~> Param_F @_ Yoneda10_Param_Forget )%sol)
(Yoneda10_Param_Forget' : Yoneda10_data Yoneda01_Param_SubstF Yoneda01_Param_F)
(Heq_subst : forall G param, sval Yoneda10_Param_Forget' G param = sval Yoneda10_Param_Forget G param)
(  Yoneda00_Form_E0 : obGenerator -> Type)
(  Yoneda01_Form_E0 : Yoneda01_data Yoneda00_Form_E0)
(  Yoneda00_Param_E0 : obGenerator -> Type)
(  Yoneda01_Param_E0 : Yoneda01_data Yoneda00_Param_E0)
(  Yoneda10_FormParam_E0 : Yoneda10_data Yoneda01_Form_E0 Yoneda01_Param_E0)
  (isFiniteness_Param_E0 : Finiteness.isFiniteness_Param_ Yoneda01_Param_E0)
  (isFiniteness_FormParam_E0 : Finiteness.isFiniteness_FormParam_ Yoneda10_FormParam_E0)
(  Yoneda10_Param_ee : Yoneda10_data Yoneda01_Param_F Yoneda01_Param_E0)
(  Yoneda10_Form_ee : Yoneda10_Form_data Yoneda10_FormParam_F Yoneda10_FormParam_E0 Yoneda10_Param_ee)
(  ff : 'CoMod ( F ~> ViewingFunctor_default isFiniteness_Param_E0 isFiniteness_FormParam_E0 @_ Yoneda10_Param_ee @^ Yoneda10_Form_ee )%sol),
  morCoMod_codomViewingFunctor ('Forget @_ Heq_subst = param_Forget o>CoMod ff)%sol .

Lemma morCoMod_codomViewingFunctorP
: forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
    (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E),
forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
  (F: @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F),
forall Yoneda10_Param_ff Yoneda10_Form_ff (ff : 'CoMod( E ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff ) %sol),
      ltac:( destruct F ; [ refine (unit : Type) | | refine (unit : Type) .. ];
               refine (morCoMod_codomViewingFunctor ff) ).
Proof.
  intros. destruct ff.
  - destruct F; [ intros; exact: tt | | intros; exact: tt .. ].
    constructor 1.
  - intros; exact: tt.
  - intros; exact: tt.
  - intros; exact: tt.
  - constructor 2.
  - intros; exact: tt.
  - destruct E.
    +  intros; exact: tt.
    +  constructor 3.
    +  intros; exact: tt.
    +  intros; exact: tt.
  - intros; exact: tt.
Defined.
End Destruct_codomViewingFunctor.

Module Destruct_codomViewedFunctor.
Inductive morCoMod_codomViewedFunctor
  : forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
                        (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E),
forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
  (F: @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F)
  (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
forall Yoneda10_Param_ff Yoneda10_Form_ff (ff : 'CoMod( E ~> ViewedFunctor_default F Param_F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff ) %sol), Type :=
| UnitCoMod : forall (Yoneda00_Form_F : obGenerator -> Type)
  (Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F)
  (Yoneda00_Param_F : obGenerator -> Type)
  (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
  (Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F)
  (F : obCoMod Yoneda10_FormParam_F)
  (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    morCoMod_codomViewedFunctor (@'UnitCoMod (ViewedFunctor_default F Param_F))%sol
| ViewedFunctor1_default : forall ( Yoneda00_Form_F : obGenerator -> Type)
(  Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F)
(  Yoneda00_Param_F : obGenerator -> Type)
 ( Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
(  Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F)
(  F : obCoMod Yoneda10_FormParam_F)
(Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F)
(  Yoneda00_Form_E : obGenerator -> Type)
(  Yoneda01_Form_E : Yoneda01_data Yoneda00_Form_E)
(  Yoneda00_Param_E : obGenerator -> Type)
(  Yoneda01_Param_E : Yoneda01_data Yoneda00_Param_E)
(  Yoneda10_FormParam_E : Yoneda10_data Yoneda01_Form_E Yoneda01_Param_E)
(  E : obCoMod Yoneda10_FormParam_E)
(Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E)
Yoneda10_Param_ff0 (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff0 )%sol)
Yoneda10_Param_ff Yoneda10_Form_ff (ff : 'CoMod( E ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff )%sol)
(Heq_param :  forall G param, sval Yoneda10_Param_ff G param = sval Yoneda10_Param_ff0 G param),
  morCoMod_codomViewedFunctor ( 'ViewedFunctor1 ff @_ Heq_param = param_ff )%sol
| UnitViewedFunctor : forall (  Yoneda00_Form_F : obGenerator -> Type)
(  Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F)
(  Yoneda00_Param_F : obGenerator -> Type)
(  Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
(  Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F)
(  F : obCoMod Yoneda10_FormParam_F)
(Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F)
(  Yoneda00_Form_E : obGenerator -> Type)
(  Yoneda01_Form_E : Yoneda01_data Yoneda00_Form_E)
(  Yoneda00_Param_E : obGenerator -> Type)
(  Yoneda01_Param_E : Yoneda01_data Yoneda00_Param_E)
(  Yoneda10_FormParam_E : Yoneda10_data Yoneda01_Form_E Yoneda01_Param_E)
(  E : obCoMod Yoneda10_FormParam_E)
(  Yoneda10_Param_ff : Yoneda10_data Yoneda01_Param_E Yoneda01_Param_F)
(  Yoneda10_Form_ff : Yoneda10_Form_data Yoneda10_FormParam_E Yoneda10_FormParam_F Yoneda10_Param_ff)
(  ff : 'CoMod ( E ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff )%sol),
    morCoMod_codomViewedFunctor (ff o>CoMod 'UnitViewedFunctor @_ Param_F)%sol
| PolyTransf_default :  forall (Yoneda00_Form_F : obGenerator -> Type)
(  Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F)
(  Yoneda00_Param_F : obGenerator -> Type)
(  Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
(  Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F)
(isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F)
(isFiniteness_FormParam_F : Finiteness.isFiniteness_FormParam_ Yoneda10_FormParam_F)
(  Yoneda10_Param_param_ : forall G : obGenerator, Yoneda00_Param_F G -> Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_F)
(  Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G), param = sval (Yoneda10_Param_param_ G param) G unitParametrizator)
(  Yoneda00_Form_E : obGenerator -> Type)
(  Yoneda01_Form_E : Yoneda01_data Yoneda00_Form_E)
(  Yoneda00_Param_E : obGenerator -> Type)
(  Yoneda01_Param_E : Yoneda01_data Yoneda00_Param_E)
(  Yoneda10_FormParam_E : Yoneda10_data Yoneda01_Form_E Yoneda01_Param_E)
(  E : obCoMod Yoneda10_FormParam_E)
(Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E)
(Yoneda10_Param_ee0 : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_E)
(param_ee0_ : forall (G : obGenerator) (param : Yoneda00_Param_F G),
          'CoMod_( View_Param (Parameter0 G) ~> Param_E
                       @_ (Yoneda10_Param_ee0 G param) )%sol)
(Yoneda10_Param_ee : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                            (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
           Yoneda10_data (Yoneda01_Param_View (Parameter0 G)) Yoneda01_Param_E)
(Yoneda10_Form_ee : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                            (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
          Yoneda10_Form_data (Yoneda10_FormParam_View G) Yoneda10_FormParam_E (Yoneda10_Param_ee G param form))
(Heq_param_ee : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                            (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
           forall G' param', sval (Yoneda10_Param_ee G param form) G' param' = sval (Yoneda10_Param_ee0 G param) G' param')
Yoneda10_Param_ee0_morphism
(Yoneda10_Form_ee_quotientLogical :
         forall G param form param' form', sval form = sval form' -> forall G0 param0 form0,
             sval (sval (Yoneda10_Form_ee G param form) G0 param0 form0)
             = sval (sval (Yoneda10_Form_ee G param' form')  G0 param0 form0))
(Yoneda10_Form_ee_morphism :
         forall (G G' : obGenerator) (g : 'Generator( G' ~> G )) (param : Yoneda00_Param_F G)
           (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
         forall (G'' : obGenerator) (param' : (Yoneda00_Param_View (Parameter0 G')) G'')
           (form' : Yoneda00_AtParam_ (Yoneda10_FormParam_View G') param'),
           sval (sval (Yoneda10_Form_ee G param form)
                      G'' (param' o>Parametrizator (Parameter1 g))
                      (form' o>GeneratorAtParam g))
           = sval (sval (Yoneda10_Form_ee G' (g o>Generator_[sval Yoneda01_Param_F] param)
                                          (g o>GeneratorAtParam_[sval (Yoneda01_AtParam_(Yoneda10_FormParam_F))] form))
                        G'' param' form'))
(ee_ : forall (G : obGenerator) (param : Yoneda00_Param_F G)
              (form : Yoneda00_AtParam_ Yoneda10_FormParam_F param),
          'CoMod( View G ~> E
                       @_ (Yoneda10_Param_ee G param form) @^ (Yoneda10_Form_ee G param form))%sol),
    morCoMod_codomViewedFunctor [[  ee_  @_ param_ee0_ , isFiniteness_Param_F , Heq_param , Heq_param_ee , Yoneda10_Param_ee0_morphism  @^ isFiniteness_FormParam_F , Yoneda10_Form_ee_quotientLogical , Yoneda10_Form_ee_morphism  ]]%sol
| Forget : forall ( Yoneda00_Form_F : obGenerator -> Type)
(  Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F)
(  Yoneda00_Param_F : obGenerator -> Type)
(  Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
(  Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F)
(  F : obCoMod Yoneda10_FormParam_F)
(  Param_F : obCoMod_Param Yoneda01_Param_F)
(  Yoneda00_Param_SubstF : obGenerator -> Type)
(  Yoneda01_Param_SubstF : Yoneda01_data Yoneda00_Param_SubstF)
(  Param_SubstF : obCoMod_Param Yoneda01_Param_SubstF)
(  Yoneda10_Param_Forget : Yoneda10_data Yoneda01_Param_SubstF Yoneda01_Param_F)
(  param_Forget : 'CoMod_ ( Param_SubstF ~> Param_F @_ Yoneda10_Param_Forget )%sol)
(  Yoneda00_Form_E0 : obGenerator -> Type)
(  Yoneda01_Form_E0 : Yoneda01_data Yoneda00_Form_E0)
(  Yoneda00_Param_E0 : obGenerator -> Type)
(  Yoneda01_Param_E0 : Yoneda01_data Yoneda00_Param_E0)
(  Yoneda10_FormParam_E0 : Yoneda10_data Yoneda01_Form_E0 Yoneda01_Param_E0)
(  E0 : obCoMod Yoneda10_FormParam_E0)
(Param_E0 : @obCoMod_Param Yoneda00_Param_E0 Yoneda01_Param_E0)
(  Yoneda10_Param_ee : Yoneda10_data Yoneda01_Param_F Yoneda01_Param_E0)
(  Yoneda10_Form_ee : Yoneda10_Form_data Yoneda10_FormParam_F Yoneda10_FormParam_E0 Yoneda10_Param_ee)
(  ff : 'CoMod ( F ~> ViewedFunctor_default E0 Param_E0 @_ Yoneda10_Param_ee @^ Yoneda10_Form_ee )%sol)
(Yoneda10_Param_Forget' : Yoneda10_data Yoneda01_Param_SubstF Yoneda01_Param_F)
(Heq_subst : forall G param, sval Yoneda10_Param_Forget' G param = sval Yoneda10_Param_Forget G param),
  morCoMod_codomViewedFunctor ('Forget @_ Heq_subst = param_Forget o>CoMod ff)%sol .

Lemma morCoMod_codomViewedFunctorP
: forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
    (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E),
forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
  (F: @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F),
forall Yoneda10_Param_ff Yoneda10_Form_ff (ff : 'CoMod( E ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff ) %sol),
      ltac:( destruct F ; [ refine (unit : Type) .. | | refine (unit : Type) ];
               refine (morCoMod_codomViewedFunctor ff) ).
Proof.
  intros. destruct ff.
  - destruct F; [ intros; exact: tt .. | | intros; exact: tt ].
    constructor 1.
  - intros; exact: tt.
  - constructor 2.
  - constructor 3.
  - intros; exact: tt.
  -  constructor 4.
  - destruct E.
    +  intros; exact: tt.
    +  intros; exact: tt.
    +  constructor 5.
    +  intros; exact: tt.
  - intros; exact: tt.
Defined.
End Destruct_codomViewedFunctor.

Module Destruct_codomSubst.
Inductive morCoMod_codomSubst
  : forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
                        (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E),
forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
  (F: @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F)
  (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall (Yoneda00_Param_SubstF : obGenerator -> Type)
      (Yoneda01_Param_SubstF : Yoneda01_data Yoneda00_Param_SubstF)
      (Param_SubstF : @obCoMod_Param Yoneda00_Param_SubstF Yoneda01_Param_SubstF),
    forall (Yoneda10_Param_subst : Yoneda10_data Yoneda01_Param_SubstF Yoneda01_Param_F),
    forall Yoneda10_Param_ff Yoneda10_Form_ff (ff : 'CoMod( E ~> Subst F Param_F Param_SubstF Yoneda10_Param_subst @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff ) %sol), Type :=
| UnitCoMod : forall (  Yoneda00_Form_F : obGenerator -> Type)
(  Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F)
(  Yoneda00_Param_F : obGenerator -> Type)
(  Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
(  Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F)
(  F : obCoMod Yoneda10_FormParam_F)
(Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F)
(  Yoneda00_Param_SubstF : obGenerator -> Type)
(  Yoneda01_Param_SubstF : Yoneda01_data Yoneda00_Param_SubstF)
(Param_SubstF : @obCoMod_Param Yoneda00_Param_SubstF Yoneda01_Param_SubstF)
(  Yoneda10_Param_subst : Yoneda10_data Yoneda01_Param_SubstF Yoneda01_Param_F),
  morCoMod_codomSubst (@'UnitCoMod (Subst F Param_F Param_SubstF Yoneda10_Param_subst)) %sol
| Forget : forall (Yoneda00_Form_F : obGenerator -> Type)
(  Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F)
(  Yoneda00_Param_F : obGenerator -> Type)
(  Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
(  Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F)
(  F : obCoMod Yoneda10_FormParam_F)
(  Param_F : obCoMod_Param Yoneda01_Param_F)
(  Yoneda00_Param_SubstF : obGenerator -> Type)
(  Yoneda01_Param_SubstF : Yoneda01_data Yoneda00_Param_SubstF)
(  Param_SubstF : obCoMod_Param Yoneda01_Param_SubstF)
(  Yoneda10_Param_Forget : Yoneda10_data Yoneda01_Param_SubstF Yoneda01_Param_F)
(  param_Forget : 'CoMod_ ( Param_SubstF ~> Param_F @_ Yoneda10_Param_Forget )%sol)
(Yoneda10_Param_Forget' : Yoneda10_data Yoneda01_Param_SubstF Yoneda01_Param_F)
(Heq_subst : forall G param, sval Yoneda10_Param_Forget' G param = sval Yoneda10_Param_Forget G param)
(  Yoneda00_Form_E0 : obGenerator -> Type)
(  Yoneda01_Form_E0 : Yoneda01_data Yoneda00_Form_E0)
(  Yoneda00_Param_E0 : obGenerator -> Type)
(  Yoneda01_Param_E0 : Yoneda01_data Yoneda00_Param_E0)
(  Yoneda10_FormParam_E0 : Yoneda10_data Yoneda01_Form_E0 Yoneda01_Param_E0)
(  E0 : obCoMod Yoneda10_FormParam_E0)
(Param_E0 : @obCoMod_Param Yoneda00_Param_E0 Yoneda01_Param_E0)
(  Yoneda00_Param_SubstE0 : obGenerator -> Type)
(  Yoneda01_Param_SubstE0 : Yoneda01_data Yoneda00_Param_SubstE0)
(Param_SubstE0 : @obCoMod_Param Yoneda00_Param_SubstE0 Yoneda01_Param_SubstE0)
(  Yoneda10_Param_subst : Yoneda10_data Yoneda01_Param_SubstE0 Yoneda01_Param_E0)
(  Yoneda10_Param_ee : Yoneda10_data Yoneda01_Param_F Yoneda01_Param_SubstE0)
(  Yoneda10_Form_ee : Yoneda10_Form_data Yoneda10_FormParam_F (Yoneda10_FormParam_Subst Yoneda10_FormParam_E0 Yoneda10_Param_subst) Yoneda10_Param_ee)
(  ff : 'CoMod ( F ~> Subst E0 Param_E0 Param_SubstE0 Yoneda10_Param_subst @_ Yoneda10_Param_ee @^ Yoneda10_Form_ee )%sol),
  morCoMod_codomSubst ('Forget @_ Heq_subst = param_Forget o>CoMod ff)%sol
| Remember : forall ( Yoneda00_Form_F : obGenerator -> Type)
(  Yoneda01_Form_F : Yoneda01_data Yoneda00_Form_F)
(  Yoneda00_Param_F : obGenerator -> Type)
(  Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
(  Yoneda10_FormParam_F : Yoneda10_data Yoneda01_Form_F Yoneda01_Param_F)
(F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F)
(  Param_F : obCoMod_Param Yoneda01_Param_F)
(  Yoneda00_Param_SubstF : obGenerator -> Type)
(  Yoneda01_Param_SubstF : Yoneda01_data Yoneda00_Param_SubstF)
(  Param_SubstF : obCoMod_Param Yoneda01_Param_SubstF)
(  Yoneda10_Param_Forget : Yoneda10_data Yoneda01_Param_SubstF Yoneda01_Param_F)
(  param_Forget : 'CoMod_ ( Param_SubstF ~> Param_F @_ Yoneda10_Param_Forget )%sol)
(L : obGenerator) Yoneda10_Param_ll Yoneda10_Form_ll
(ll : 'CoMod( View L ~> F @_ Yoneda10_Param_ll @^ Yoneda10_Form_ll ) %sol)
(Yoneda10_Param_ll_ : Yoneda10_data (Yoneda01_Param_View (Parameter0 L)) Yoneda01_Param_SubstF)
(Heq_param : forall G param, sval Yoneda10_Param_ll G param
                        = sval (Yoneda10_Param_PolyCoMod Yoneda10_Param_ll_ Yoneda10_Param_Forget) G param)
(Yoneda10_Param_Forget' : Yoneda10_data Yoneda01_Param_SubstF Yoneda01_Param_F)
(Heq_subst : forall G param, sval Yoneda10_Param_Forget' G param = sval Yoneda10_Param_Forget G param),
  morCoMod_codomSubst ( <<  ll  @_  Heq_param  =  Yoneda10_Param_ll_  ,  Heq_subst = param_Forget  >> %sol) .

Lemma morCoMod_codomSubstP
: forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
    (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E),
forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
  (F: @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F),
forall Yoneda10_Param_ff Yoneda10_Form_ff (ff : 'CoMod( E ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff ) %sol),
      ltac:( destruct F ; [ refine (unit : Type) .. | ];
               refine (morCoMod_codomSubst ff) ).
Proof.
  intros. destruct ff.
  - destruct F; [ intros; exact: tt .. | ].
    constructor 1.
  - intros; exact: tt.
  - intros; exact: tt.
  - intros; exact: tt.
  - intros; exact: tt.
  - intros; exact: tt.
  - destruct E.
    +  intros; exact: tt.
    +  intros; exact: tt.
    +  intros; exact: tt.
    + constructor 2.
  - constructor 3.
Defined.
End Destruct_codomSubst.

(* ----- param ----- *)
Module DestructParam.
Module Destruct_codomView.
Inductive morCoMod_codomView
: forall Yoneda00_Param_E Yoneda01_Param_E
    (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E ),
    forall P : obParametrizator, forall Yoneda10_Param_ff
        (param_ff : 'CoMod_( Param_E ~> View_Param P @_ Yoneda10_Param_ff )%sol), Type :=
| UnitCoMod_Param :  forall P : obParametrizator,
    morCoMod_codomView ( ( @'UnitCoMod_ (View_Param P) )%sol )

| View1_Param :  forall (G : obGenerator) (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
    forall (Q : obParametrizator) (p : 'Parametrizator( P ~> Q )),
    morCoMod_codomView ( ( 'View1_ is_Parameter0_P p )%sol ) .

Lemma morCoMod_codomViewP
  : forall Yoneda00_Param_E Yoneda01_Param_E
    (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E ),
    forall  Yoneda00_Param_F Yoneda01_Param_F
    (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F ),
    forall Yoneda10_Param_ff (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff ) %sol),
      ltac:( destruct Param_F; [ | refine (unit : Type) .. ];
               refine (morCoMod_codomView param_ff) ).
Proof.
  intros. destruct param_ff.
  - destruct Param_F; [ | intros; exact: tt .. ].
    constructor 1.
  - constructor 2.
  - intros; exact: tt.
  - intros; exact: tt.
  - intros; exact: tt.
  - intros; exact: tt.
  - intros; exact: tt.
Defined.
End Destruct_codomView.

Module Destruct_codomViewingFunctor.
Inductive morCoMod_codomViewingFunctor
  : forall Yoneda00_Param_E Yoneda01_Param_E
    (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E ),
    forall Yoneda00_Param_F (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
      (isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F),
forall Yoneda10_Param_ff (param_ff : 'CoMod_( Param_E ~> ViewingFunctor_Param_default isFiniteness_Param_F @_ Yoneda10_Param_ff ) %sol), Type :=
| UnitCoMod : forall (Yoneda00_Param_F : obGenerator -> Type)
                (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
                (isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F),
    morCoMod_codomViewingFunctor (@'UnitCoMod_ (ViewingFunctor_Param_default isFiniteness_Param_F))%sol
| PolyElement_default : forall (Yoneda00_Param_F : obGenerator -> Type)
  (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
  (isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F)
  (Yoneda10_Param_param_ : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                             (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
      Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_F )
  (Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                 (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
      param = sval (Yoneda10_Param_param_ G param P is_Parameter0_P)
                   G (is_Parameter0_transp_rev_codom is_Parameter0_P (@unitParametrizator (Parameter0 G))) )
  Yoneda10_Param_param_morphism,
    forall (G : obGenerator) (param : Yoneda00_Param_F G) (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),

  morCoMod_codomViewingFunctor ('PolyElement_ param @_ isFiniteness_Param_F , is_Parameter0_P , Heq_param, Yoneda10_Param_param_morphism)%sol .

Lemma morCoMod_codomViewingFunctorP
  : forall Yoneda00_Param_E Yoneda01_Param_E
    (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E ),
    forall  Yoneda00_Param_F Yoneda01_Param_F
    (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F ),
    forall Yoneda10_Param_ff (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff ) %sol),
      ltac:( destruct Param_F ; [ refine (unit : Type) | | refine (unit : Type) .. ];
               refine (morCoMod_codomViewingFunctor param_ff) ).
Proof.
  intros. destruct param_ff.
  - destruct Param_F; [ intros; exact: tt | | intros; exact: tt .. ].
    constructor 1.
  - intros; exact: tt.
  - intros; exact: tt.
  - intros; exact: tt.
  - constructor 2.
  - intros; exact: tt.
  - intros; exact: tt.
Defined.
End Destruct_codomViewingFunctor.

Module Destruct_codomViewedFunctor.
Inductive morCoMod_codomViewedFunctor
  : forall Yoneda00_Param_E Yoneda01_Param_E
    (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E ),
forall Yoneda00_Param_F Yoneda01_Param_F
    (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F ),
forall Yoneda10_Param_ff (param_ff : 'CoMod_( Param_E ~> ViewedFunctor_Param_default Param_F @_ Yoneda10_Param_ff ) %sol), Type :=
| UnitCoMod : forall (Yoneda00_Param_F : obGenerator -> Type)
  (Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
  (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    morCoMod_codomViewedFunctor (@'UnitCoMod_ (ViewedFunctor_Param_default Param_F))%sol
| ViewedFunctor1_default : forall (  Yoneda00_Param_F : obGenerator -> Type)
 ( Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
(Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F)
(  Yoneda00_Param_E : obGenerator -> Type)
(  Yoneda01_Param_E : Yoneda01_data Yoneda00_Param_E)
(Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E)
Yoneda10_Param_ff (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff )%sol),
  morCoMod_codomViewedFunctor ( 'ViewedFunctor1_ param_ff )%sol
| UnitViewedFunctor : forall (  Yoneda00_Param_F : obGenerator -> Type)
(  Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
(Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F)
(  Yoneda00_Param_E : obGenerator -> Type)
(  Yoneda01_Param_E : Yoneda01_data Yoneda00_Param_E)
(Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E )
(  Yoneda10_Param_ff : Yoneda10_data Yoneda01_Param_E Yoneda01_Param_F)
(  param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff )%sol),
    morCoMod_codomViewedFunctor (param_ff o>CoMod_ 'UnitViewedFunctor_)%sol
| PolyTransf_default :  forall (  Yoneda00_Param_F : obGenerator -> Type)
(  Yoneda01_Param_F : Yoneda01_data Yoneda00_Param_F)
(isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F)
(Yoneda10_Param_param_ : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                           (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
    Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_F )
(Heq_param : forall (G : obGenerator) (param : Yoneda00_Param_F G)
               (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
    param = sval (Yoneda10_Param_param_ G param P is_Parameter0_P)
                 G (is_Parameter0_transp_rev_codom is_Parameter0_P (@unitParametrizator (Parameter0 G))) )
Yoneda00_Param_E Yoneda01_Param_E
(Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E)
(Yoneda10_Param_ee : forall (G : obGenerator) (param : Yoneda00_Param_F G)
                       (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
    Yoneda10_data (Yoneda01_Param_View P) Yoneda01_Param_E)
Yoneda10_Param_ee_morphism
(param_ee_ : forall (G : obGenerator) (param : Yoneda00_Param_F G)
               (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
    'CoMod_( View_Param P ~> Param_E @_ (Yoneda10_Param_ee G param P is_Parameter0_P) )%sol),
    morCoMod_codomViewedFunctor [[_  param_ee_  @_ isFiniteness_Param_F , Heq_param , Yoneda10_Param_ee_morphism  ]] %sol .

Lemma morCoMod_codomViewedFunctorP
  : forall Yoneda00_Param_E Yoneda01_Param_E
    (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E ),
    forall  Yoneda00_Param_F Yoneda01_Param_F
    (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F ),
    forall Yoneda10_Param_ff (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff ) %sol),
      ltac:( destruct Param_F ; [ refine (unit : Type) .. | | refine (unit : Type) ];
               refine (morCoMod_codomViewedFunctor param_ff) ).
Proof.
  intros. destruct param_ff.
  - destruct Param_F; [ intros; exact: tt .. | | intros; exact: tt ].
    constructor 1.
  - intros; exact: tt.
  - constructor 2.
  - constructor 3.
  - intros; exact: tt.
  -  constructor 4.
  - intros; exact: tt.
Defined.
End Destruct_codomViewedFunctor.

Module Destruct_codomFormat.
Inductive morCoMod_codomFormat
: forall Yoneda00_Param_E Yoneda01_Param_E
    (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E ),
    forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
      (F: @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F)
      (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda10_Param_ff
      (param_ff : 'CoMod_( Param_E ~> Format F Param_F @_ Yoneda10_Param_ff )%sol), Type :=
| UnitCoMod_Param : forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
            (F: @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F)
            (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
      morCoMod_codomFormat ( ( @'UnitCoMod_ (Format F Param_F) )%sol )

| Formatting : forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
      (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E)
      (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
    forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
      (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F)
      (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
    forall Yoneda10_Param_ff0
      (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff0 )%sol),
    forall Yoneda10_Param_ff Yoneda10_Form_ff
      (ff : 'CoMod( E ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff )%sol ),
    morCoMod_codomFormat ( ( 'Formatting ff @_ param_ff )%sol ) .

Lemma morCoMod_codomFormatP
  : forall Yoneda00_Param_E Yoneda01_Param_E
    (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E ),
    forall  Yoneda00_Param_F Yoneda01_Param_F
    (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F ),
    forall Yoneda10_Param_ff (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff ) %sol),
      ltac:( destruct Param_F; [ refine (unit : Type) .. | ];
               refine (morCoMod_codomFormat param_ff) ).
Proof.
  intros. destruct param_ff.
  - destruct Param_F; [ intros; exact: tt .. |  ].
    constructor 1.
  - intros; exact: tt.
  - intros; exact: tt.
  - intros; exact: tt.
  - intros; exact: tt.
  - intros; exact: tt.
  - constructor 2.
Defined.
End Destruct_codomFormat.
End DestructParam.
End Sol.
(** # #
#+END_SRC

* Polymorphism/cut-elimination by computational/total/asymptotic/reduction/(multi-step) resolution

  As common , this resolution is not programmed by morphisms-structural recursion but instead is programmed by grade-structural recursion .

  In contrast , this resolution also computes the sense-decoding datatype-index/argument of the resolved morphism , this datatype-index/argument is inferred as metavariable from the actual resolved morphism via the [eexists] tactic . The technical progress of this resolution does require the earlier lemma [convCoMod_sense] , which will only be used during the polymorphism/cut-elimination resolution [solveCoMod] to show/transfer the logical-properties which are carried-as-arguments by the many morphisms constructors ( [Heq_param] , [Heq_subst] , [Yoneda10_Form_ee_morphism] ... )

  This COQ program and deduction is mostly-automated ; but memo that COQ lacks inductive-recursive presentations and memo that here the automation-tactics use only logical eauto-resolution because COQ lacks some more-efficient heterogeneous-rewriting tactics , because the conversion-relation do convert across two morphisms whose sense-decoding indexes are not syntactically/grammatically-the-same .

#+BEGIN_SRC coq :exports both :results silent # # **)
Module Resolve.
Export Sol.Ex_Notations.

Ltac tac_degrade H_grade :=
  intuition idtac;
  repeat match goal with
         | [ Hred : ( _ <~~ _ )%poly |- _ ] =>
           move : (degrade Hred) ; clear Hred
         | [ Hred : ( _ <~~_ _ )%poly |- _ ] =>
           move : (degrade_param Hred) ; clear Hred
         | [ isFiniteness_Param_F : Finiteness.isFiniteness_Param_ ?Yoneda01_Param_F,
             isFiniteness_FormParam_F : Finiteness.isFiniteness_FormParam_ ?Yoneda10_FormParam_F,
             Hred : (forall (G : obGenerator) (param : ?Yoneda00_Param_F G)
                         (form : Yoneda00_AtParam_ ?Yoneda10_FormParam_F param),
                          ( _ <~~ _ )%poly)
             |- _ ] =>
           move: {Hred} (degrade (Hred ( _ )( _ )(Finiteness.form1 isFiniteness_FormParam_F (Finiteness.param1 isFiniteness_Param_F))))
                          (degrade (Hred ( _ )( _ )(Finiteness.form2 isFiniteness_FormParam_F (Finiteness.param1 isFiniteness_Param_F))))
                          (degrade (Hred ( _ )( _ )(Finiteness.form1 isFiniteness_FormParam_F (Finiteness.param2 isFiniteness_Param_F))))
                          (degrade (Hred ( _ )( _ )(Finiteness.form2 isFiniteness_FormParam_F (Finiteness.param2 isFiniteness_Param_F))));
           rewrite ?grade_rewrite
         | [ isFiniteness_Param_F : Finiteness.isFiniteness_Param_ ?Yoneda01_Param_F,
             Hred : (forall (G : obGenerator) (param : ?Yoneda00_Param_F G)
                       (P : obParametrizator) (is_Parameter0_P : is_Parameter0 G P),
                        ( _ <~~_ _ )%poly)
             |- _ ] =>
           move: {Hred} (degrade_param (Hred ( _ )(Finiteness.param1 isFiniteness_Param_F)(_)(Is_Parameter0 _)))
                          (degrade_param (Hred ( _ )(Finiteness.param2 isFiniteness_Param_F)(_)(Is_Parameter0 _)));
           rewrite ?grade_rewrite
         end;
  move: H_grade; clear; rewrite ?(Sol.toPolyMor_mut_rewrite, grade_rewrite);
  intros; try tac_grade_gt0; try tac_grade_param_gt0;
  try tac_grade_gt0_parametric; try tac_grade_param_gt0_parametric;
  intros; Lia.lia.

Ltac tac_simpl := rewrite ?grade_rewrite; rewrite ?Sol.toPolyMor_mut_rewrite;
                  cbn -[grade grade_param Sol.toPolyMor Sol.toPolyMor_param].
(*MEMO: one single [tac_simpl] was enough in old [COQ] , why the new change ? *)
Ltac tac_reduce := tac_simpl; repeat (intro; tac_simpl); intuition eauto.

Fixpoint solveCoMod len {struct len} :
 forall Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
   (E : @obCoMod Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E),
 forall Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F
   (F : @obCoMod Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F),
 forall Yoneda10_Param_ff Yoneda10_Form_ff (ff : 'CoMod( E ~> F @_ Yoneda10_Param_ff @^ Yoneda10_Form_ff )),
 forall grade_ff : (grade ff <= len)%nat,
   { ffSol : { Yoneda10_Param_ffSol : _ & { Yoneda10_Form_ffSol : _ & 'CoMod( E ~> F @_ Yoneda10_Param_ffSol @^ Yoneda10_Form_ffSol )%sol } }
   | (Sol.toPolyMor (projT2 (projT2 ffSol))) <~~ ff }

with solveCoMod_param len {struct len} :
 forall Yoneda00_Param_E Yoneda01_Param_E (Param_E : @obCoMod_Param Yoneda00_Param_E Yoneda01_Param_E),
 forall Yoneda00_Param_F Yoneda01_Param_F (Param_F : @obCoMod_Param Yoneda00_Param_F Yoneda01_Param_F),
 forall Yoneda10_Param_ff (param_ff : 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ff )),
 forall grade_param_ff : (grade_param param_ff <= len)%nat,
   { param_ffSol : { Yoneda10_Param_ffSol : _ & 'CoMod_( Param_E ~> Param_F @_ Yoneda10_Param_ffSol )%sol }
   | (Sol.toPolyMor_param (projT2 param_ffSol)) <~~_ param_ff } .
Proof.
{ (** solveCoMod **) case : len => [ | len ].

(** len is O **)
- intros Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E E Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F F Yoneda10_Param_ff
         Yoneda10_Form_ff ff grade_ff; exfalso;
    clear - grade_ff; abstract tac_degrade grade_ff.

(** len is (S len) **)
-  intros Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E E Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F F Yoneda10_Param_ff
         Yoneda10_Form_ff ff.  case : Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E E Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F F Yoneda10_Param_ff
                                                      Yoneda10_Form_ff  / ff;
   [ intros Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F F Yoneda00_Form_F' Yoneda01_Form_F' Yoneda00_Param_F' Yoneda01_Param_F' Yoneda10_FormParam_F' F' Yoneda10_Param_ff'
          Yoneda10_Form_ff' ff' Yoneda00_Form_F'' Yoneda01_Form_F'' Yoneda00_Param_F'' Yoneda01_Param_F'' Yoneda10_FormParam_F'' F'' Yoneda10_Param_ff_ Yoneda10_Form_ff_ ff_ grade_ff
   | intros Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F F grade_ff
   | intros G H g grade_ff
   | intros Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F F Param_F Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E E Param_E
                                        Yoneda10_Param_ff0 param_ff Yoneda10_Param_ff Yoneda10_Form_ff ff Heq_param grade_ff
   | intros Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F F Param_F Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E E Yoneda10_Param_ff
          Yoneda10_Form_ff ff grade_ff
   | intros Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F isFiniteness_Param_F isFiniteness_FormParam_F Yoneda10_Param_param_ Heq_param Yoneda10_Param_param_morphism G param form grade_ff
   | intros Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F isFiniteness_Param_F isFiniteness_FormParam_F Yoneda10_Param_param_ Heq_param Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
                                    E Param_E Yoneda10_Param_ee0 param_ee0_ Yoneda10_Param_ee Yoneda10_Form_ee Heq_param_ee Yoneda10_Param_ee0_morphism Yoneda10_Form_ee_quotientLogical Yoneda10_Form_ee_morphism ee_ grade_ff
   | intros Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F F Param_F Yoneda00_Param_SubstF Yoneda01_Param_SubstF Param_SubstF Yoneda10_Param_Forget param_Forget
       Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E E Yoneda10_Param_ee Yoneda10_Form_ee ee  Yoneda10_Param_Forget' Heq_subst grade_ff
   | intros Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F F Param_F Yoneda00_Param_SubstF Yoneda01_Param_SubstF Param_SubstF Yoneda10_Param_Forget param_Forget
       L Yoneda10_Param_ll Yoneda10_Form_ll ll Yoneda10_Param_ll_  Heq_param Yoneda10_Param_Forget' Heq_subst grade_ff ].

(** ff is ff_ o>CoMod ff' *) all: cycle 1.

(** ff is @'UnitCoMod F **)
+ unshelve eexists. do 2eexists. refine ( @'UnitCoMod F )%sol.
  clear; abstract exact: convCoMod_Refl.

(** ff is 'View1 g **)
+ unshelve eexists. do 2 eexists. refine ( 'View1 g )%sol.
  clear; abstract exact: convCoMod_Refl.

(** ff is 'ViewedFunctor1 ff @_ param_ff **)
+ have [:blurb] ffSol_transp :=
    (proj2_sig (solveCoMod len _ _ _ _ _ _ _ _ _ _ _ _ _ _ ff blurb));
      first by clear -grade_ff; abstract tac_degrade grade_ff.
  move: (projT1 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _  ff blurb)))
          (projT1 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _  ff blurb))))
          (projT2 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _ ff blurb)))) ffSol_transp
  => Yoneda10_Param_ffSol Yoneda10_Form_ffSol ffSol ffSol_transp .
  have [:blurbp] param_ffSol_transp :=
    (proj2_sig (solveCoMod_param len _ _ _  _ _ _  _ param_ff blurbp));
      first by clear -grade_ff; abstract tac_degrade grade_ff.
  move:   (projT1 (sval (solveCoMod_param len _ _ _  _ _ _  _ param_ff blurbp)))
          (projT2 (sval (solveCoMod_param len _ _ _  _ _ _  _ param_ff blurbp))) param_ffSol_transp
  => Yoneda10_Param_ffSol0 param_ffSol param_ffSol_transp .
  clear solveCoMod solveCoMod_param.

  unshelve eexists. do 2 eexists. refine ( 'ViewedFunctor1 ffSol @_ _ = param_ffSol )%sol.

  (** Heq_param *)
  { clear -Heq_param ffSol_transp param_ffSol_transp.
    abstract ((move : (convCoMod_sense ffSol_transp) => ffSol_transp_eq);
              (move: (convCoMod_sense_param param_ffSol_transp) => param_ffSol_transp_eq);
              intros; rewrite (proj1 ffSol_transp_eq) param_ffSol_transp_eq Heq_param // ). }

  move: param_ffSol_transp ffSol_transp; clear; abstract tac_reduce.

(** ff is ff o>CoMod 'UnitViewedFunctor @_ Param_F **)
+ have [:blurb] ffSol_transp :=
    (proj2_sig (solveCoMod len _ _ _ _ _ _ _ _ _ _ _ _ _ _ ff blurb));
      first by clear -grade_ff; abstract tac_degrade grade_ff.
  move: (projT1 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _  ff blurb)))
          (projT1 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _  ff blurb))))
          (projT2 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _ ff blurb)))) ffSol_transp
  => Yoneda10_Param_ffSol Yoneda10_Form_ffSol ffSol ffSol_transp .
  clear solveCoMod solveCoMod_param.

  unshelve eexists. do 2 eexists. refine ( ffSol o>CoMod 'UnitViewedFunctor @_ Param_F )%sol.
  move: ffSol_transp; clear; abstract tac_reduce.

(** ff is 'PolyElement form @_ isFiniteness_Param_F , Heq_param  , Yoneda10_Param_param_morphism @^ isFiniteness_FormParam_F **)
+ unshelve eexists. do 2 eexists. refine ( 'PolyElement  form  @_  isFiniteness_Param_F , Heq_param , Yoneda10_Param_param_morphism @^ isFiniteness_FormParam_F )%sol.
  clear; abstract exact: convCoMod_Refl.

(** ff is [[ ee_ @_ param_ee0_ @^ isFiniteness_FormParam_F ]] **)
+ have [:blurb_] eeSol_transp G param form :=
    (proj2_sig (solveCoMod len _ _ _ _ _ _ _ _ _ _ _ _ _ _ (ee_(G)(param)(form)) (blurb_ G param form)));
      first by clear -grade_ff;
      abstract((move => G param form);
               match goal with
               | [ isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F ,
                   isFiniteness_FormParam_F : Finiteness.isFiniteness_FormParam_ Yoneda10_FormParam_F  |- _ ] =>
                 destruct (Finiteness.is_viewingFunctorParamElement12_allP isFiniteness_Param_F param);
                 destruct (Finiteness.is_viewingFunctorElement12_allP isFiniteness_FormParam_F form)
               end; tac_degrade grade_ff).
  have @Yoneda10_Param_eeSol_ := (fun G param form =>
     projT1 (sval (solveCoMod len _ _ _ _ _ _ _ _ _ _ _ _ _ _ (ee_(G)(param)(form)) (blurb_ G param form)))).
  have @Yoneda10_Form_eeSol_ : (forall G param form,
      Yoneda10_Form_data (Yoneda10_FormParam_View G) Yoneda10_FormParam_E (Yoneda10_Param_eeSol_ G param form) )
    := (fun G param form =>
     projT1 (projT2 (sval (solveCoMod len _ _ _ _ _ _ _ _ _ _ _ _ _ _ (ee_(G)(param)(form)) (blurb_ G param form))))).
  have @eeSol_ : (forall G param form,
   'CoMod( View G ~> E @_ Yoneda10_Param_eeSol_ G param form @^ Yoneda10_Form_eeSol_ G param form ) %sol)
    := (fun G param form => projT2 (projT2 (sval (solveCoMod len _ _ _ _ _ _ _ _ _ _ _ _ _ _
                                                (ee_(G)(param)(form)) (blurb_ G param form))))) .
  have {eeSol_transp}: (forall G param form,
                         Sol.toPolyMor (eeSol_(G)(param)(form)) <~~ ee_(G)(param)(form)) := eeSol_transp.
  move: Yoneda10_Param_eeSol_ Yoneda10_Form_eeSol_ eeSol_ => Yoneda10_Param_eeSol_ Yoneda10_Form_eeSol_ eeSol_ eeSol_transp.

  have [:blurbp_] param_eeSol0_transp G param :=
    (proj2_sig (solveCoMod_param len _ _ _  _ _ _  _ (param_ee0_(G)(param)) (blurbp_ G param)));
      first by clear -grade_ff;
      abstract((move => G param);
               match goal with
               | [ isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F |- _ ] =>
                 destruct (Finiteness.is_viewingFunctorParamElement12_allP isFiniteness_Param_F param)
               end;
               tac_degrade grade_ff).
  have @Yoneda10_Param_eeSol0_ := (fun G param =>
     projT1 (sval (solveCoMod_param len _ _ _  _ _ _  _ (param_ee0_(G)(param)) (blurbp_ G param)))).
  have @param_eeSol0_ : (forall G param,
   'CoMod_( View_Param (Parameter0 G) ~> Param_E @_ Yoneda10_Param_eeSol0_ G param ) %sol)
    := (fun G param => (projT2 (sval (solveCoMod_param len _ _ _  _ _ _  _
                                                (param_ee0_(G)(param)) (blurbp_ G param))))) .
  have {param_eeSol0_transp}: (forall G param,
                         Sol.toPolyMor_param (param_eeSol0_(G)(param)) <~~_ param_ee0_(G)(param)) := param_eeSol0_transp.
  move: Yoneda10_Param_eeSol0_ param_eeSol0_ => Yoneda10_Param_eeSol0_ param_eeSol0_ param_eeSol0_transp.
  clear solveCoMod solveCoMod_param.

  unshelve eexists. do 2 eexists.
  refine ( [[  eeSol_  @_ param_eeSol0_ , isFiniteness_Param_F , Heq_param , _ , _  @^ isFiniteness_FormParam_F , _ , _  ]] %sol ).

  (** Heq_param_ee *)
  { clear -Heq_param_ee eeSol_transp param_eeSol0_transp;
    abstract ((move : (fun G param form => convCoMod_sense (eeSol_transp G param form)) => eeSol_transp_eq);
              (move: (fun G param => convCoMod_sense_param (param_eeSol0_transp G param)) => param_eeSol0_transp_eq);
              intros; rewrite (proj1 (eeSol_transp_eq _ _ _)) (param_eeSol0_transp_eq _ _);
              exact: Heq_param_ee).
  }
  (** Yoneda10_Param_ee0_morphism *)
  { clear -Yoneda10_Param_ee0_morphism param_eeSol0_transp.
    abstract ((move: (fun G param => convCoMod_sense_param (param_eeSol0_transp G param)) => param_eeSol0_transp_eq);
    intros; do 2 rewrite (param_eeSol0_transp_eq _ _);
    exact: Yoneda10_Param_ee0_morphism).
  }
  (** Yoneda10_Form_ee_quotientLogical *)
  { clear -Yoneda10_Form_ee_quotientLogical eeSol_transp.
    abstract((move : (fun G param form => convCoMod_sense (eeSol_transp G param form)) => eeSol_transp_eq);
             intros; do 2 rewrite (proj2 (eeSol_transp_eq _ _ _)); exact: Yoneda10_Form_ee_quotientLogical).
  }
  (** Yoneda10_Form_ee_morphism *)
  { clear -Yoneda10_Form_ee_morphism eeSol_transp.
    abstract((move : (fun G param form => convCoMod_sense (eeSol_transp G param form)) => eeSol_transp_eq);
             intros; do 2 rewrite (proj2 (eeSol_transp_eq _ _ _)); exact: Yoneda10_Form_ee_morphism).
  }

  move: eeSol_transp param_eeSol0_transp; clear; abstract tac_reduce.

(** ff is 'Forget @_ param_Forget o>CoMod ee **)
+ have [:blurb] eeSol_transp :=
    (proj2_sig (solveCoMod len _ _ _ _ _ _ _ _ _ _ _ _ _ _ ee blurb));
      first by clear -grade_ff; abstract tac_degrade grade_ff.
  move: (projT1 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _  ee blurb)))
          (projT1 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _  ee blurb))))
          (projT2 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _ ee blurb)))) eeSol_transp
  => Yoneda10_Param_eeSol Yoneda10_Form_eeSol eeSol eeSol_transp .

  have [:blurbp] param_ForgetSol_transp :=
    (proj2_sig (solveCoMod_param len _ _ _  _ _ _  _ param_Forget blurbp));
      first by clear -grade_ff; abstract tac_degrade grade_ff.
  move:   (projT1 (sval (solveCoMod_param len _ _ _  _ _ _  _ param_Forget blurbp)))
          (projT2 (sval (solveCoMod_param len _ _ _  _ _ _  _ param_Forget blurbp))) param_ForgetSol_transp
  => Yoneda10_Param_ForgetSol0 param_ForgetSol param_ForgetSol_transp .
  clear solveCoMod solveCoMod_param.

  unshelve eexists. do 2 eexists. refine ( 'Forget @_ _ = param_ForgetSol o>CoMod eeSol )%sol.

  (** Heq_subst *)
  { clear -Heq_subst param_ForgetSol_transp.
    abstract ((move: (convCoMod_sense_param param_ForgetSol_transp) => param_ForgetSol_transp_eq);
              intros; rewrite param_ForgetSol_transp_eq; exact: Heq_subst).
  }

  move: param_ForgetSol_transp eeSol_transp; clear; abstract tac_reduce.

(** ff is << ll @_ Heq_param  = Yoneda10_Param_ll_ , Heq_subst = param_Forget >>  **)
+ have [:blurb] llSol_transp :=
    (proj2_sig (solveCoMod len _ _ _ _ _ _ _ _ _ _ _ _ _ _ ll blurb));
      first by clear -grade_ff; abstract tac_degrade grade_ff.
  move: (projT1 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _  ll blurb)))
          (projT1 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _  ll blurb))))
          (projT2 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _ ll blurb)))) llSol_transp
  => Yoneda10_Param_llSol Yoneda10_Form_llSol llSol llSol_transp .

  have [:blurbp] param_ForgetSol_transp :=
    (proj2_sig (solveCoMod_param len _ _ _  _ _ _  _ param_Forget blurbp));
      first by clear -grade_ff; abstract tac_degrade grade_ff.
  move:   (projT1 (sval (solveCoMod_param len _ _ _  _ _ _  _ param_Forget blurbp)))
          (projT2 (sval (solveCoMod_param len _ _ _  _ _ _  _ param_Forget blurbp))) param_ForgetSol_transp
  => Yoneda10_Param_ForgetSol0 param_ForgetSol param_ForgetSol_transp .
  clear solveCoMod solveCoMod_param.

  unshelve eexists. do 2 eexists. refine ( << llSol @_ _ = Yoneda10_Param_ll_ , _ = param_ForgetSol >> )%sol.

  (** Heq_param *)
  { clear -Heq_param llSol_transp param_ForgetSol_transp.
    abstract ((move : (convCoMod_sense llSol_transp) => llSol_transp_eq);
              (move: (convCoMod_sense_param param_ForgetSol_transp) => param_ForgetSol_transp_eq);
              intros; simpl; rewrite (proj1 llSol_transp_eq) param_ForgetSol_transp_eq /= Heq_param; reflexivity).
  }
  (** Heq_subst *)
  { clear -Heq_subst param_ForgetSol_transp.
    abstract ((move: (convCoMod_sense_param param_ForgetSol_transp) => param_ForgetSol_transp_eq);
              intros; rewrite param_ForgetSol_transp_eq; exact: Heq_subst).
  }

  move: param_ForgetSol_transp llSol_transp; clear; abstract tac_reduce.

(** ff is ff_ o>CoMod ff' **)
+ have [:blurb] ff'Sol_transp :=
    (proj2_sig (solveCoMod len _ _ _ _ _ _ _ _ _ _ _ _ _ _ ff' blurb));
      first by clear -grade_ff; abstract tac_degrade grade_ff.
  move: (projT1 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _  ff' blurb)))
          (projT1 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _  ff' blurb))))
          (projT2 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _ ff' blurb)))) ff'Sol_transp
  => Yoneda10_Param_ff'Sol Yoneda10_Form_ff'Sol ff'Sol ff'Sol_transp .
  have [:blurb] ff_Sol_transp :=
    (proj2_sig (solveCoMod len _ _ _ _ _ _ _ _ _ _ _ _ _ _ ff_ blurb));
      first by clear -grade_ff; abstract tac_degrade grade_ff.
  move: (projT1 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _  ff_ blurb)))
          (projT1 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _  ff_ blurb))))
          (projT2 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _ ff_ blurb)))) ff_Sol_transp
  => Yoneda10_Param_ff_Sol Yoneda10_Form_ff_Sol ff_Sol ff_Sol_transp .

  (** ff is (ff_ o>CoMod ff') , to (ff_Sol o>CoMod ff'Sol)  **)
  destruct ff'Sol as
   [ Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F F
   |  G H g
   |  Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F F Param_F Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E E Param_E
                                        Yoneda10_Param_ff0 param_ff Yoneda10_Param_ff Yoneda10_Form_ff ff Heq_param
   |  Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F F Param_F Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E E Yoneda10_Param_ff
          Yoneda10_Form_ff ff
   |  Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F isFiniteness_Param_F isFiniteness_FormParam_F Yoneda10_Param_param_ Heq_param Yoneda10_Param_param_morphism G param form
   |  Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F isFiniteness_Param_F isFiniteness_FormParam_F  Yoneda10_Param_param_ Heq_param Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E
                                    E Param_E Yoneda10_Param_ee0 param_ee0_ Yoneda10_Param_ee Yoneda10_Form_ee Heq_param_ee Yoneda10_Param_ee0_morphism Yoneda10_Form_ee_quotientLogical Yoneda10_Form_ee_morphism ee_
   |  Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F F Param_F Yoneda00_Param_SubstF Yoneda01_Param_SubstF Param_SubstF Yoneda10_Param_Forget param_Forget
      Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E E Yoneda10_Param_ee Yoneda10_Form_ee ee  Yoneda10_Param_Forget' Heq_subst
   |  Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F F Param_F Yoneda00_Param_SubstF Yoneda01_Param_SubstF Param_SubstF Yoneda10_Param_Forget param_Forget
      L Yoneda10_Param_ll Yoneda10_Form_ll ll Yoneda10_Param_ll_  Heq_param Yoneda10_Param_Forget' Heq_subst ].

  (** ff is (ff_ o>CoMod ff') , to (ff_Sol o>CoMod ff'Sol)  ,
is (ff_Sol o>CoMod (@'UnitCoMod F)) **)
  * unshelve eexists. do 2 eexists. refine (ff_Sol)%sol.
    move:ff_Sol_transp ff'Sol_transp; clear;
      abstract (tac_simpl; intros; eapply convCoMod_Trans with
                                   (uTrans := ff_ o>CoMod ('UnitCoMod)); tac_reduce).

  (** ff is (ff_ o>CoMod ff') , to (ff_Sol o>CoMod ff'Sol)  ,
is (ff_Sol o>CoMod ('View1 g)) **)
  * move: (Sol.Destruct_codomView.morCoMod_codomViewP ff_Sol) => ff_Sol_codomViewP.
    { destruct ff_Sol_codomViewP as
          [ _G
          | _G H _g
          | Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F F Param_F Yoneda00_Param_SubstF Yoneda01_Param_SubstF Param_SubstF Yoneda10_Param_Forget param_Forget Yoneda10_Param_Forget' Heq_subst _G Yoneda10_Param_ee Yoneda10_Form_ee ff].

      (** ff is (ff_ o>CoMod ff') , to (ff_Sol o>CoMod ff'Sol)  ,
is (( @'UnitCoMod (View _G) ) o>CoMod ( 'View1 g )) **)
      - unshelve eexists. do 2 eexists. refine ('View1 g)%sol.
        move: ff_Sol_transp ff'Sol_transp; clear;
          abstract (tac_simpl; intros; eapply convCoMod_Trans with
                                       (uTrans := ('UnitCoMod) o>CoMod ('View1 g)); tac_reduce).

      (** ff is (ff_ o>CoMod ff') , to (ff_Sol o>CoMod ff'Sol)  ,
is (( 'View1 _g ) o>CoMod ( 'View1 g )) **)
      - unshelve eexists. do 2 eexists.
        refine ( 'View1 (_g o>Generator g) )%sol.
        move: ff_Sol_transp ff'Sol_transp; clear;
          abstract (tac_simpl; intros; eapply convCoMod_Trans with
                                       (uTrans := ('View1 _g) o>CoMod ('View1 g)); tac_reduce).

      (** ff is (ff_ o>CoMod ff') , to (ff_Sol o>CoMod ff'Sol)  ,
is (( 'Forget @_ Heq_subst = param_Forget o>CoMod ff ) o>CoMod ( 'View1 g )) **)
      - pose Sol_toPolyMor_ff'Sol := ( 'View1 g ).
        have [:blurb] ff_o_g_transp :=
          (proj2_sig (solveCoMod len _ _ _ _ _ _ _ _ _ _ _ _ _ _ (Sol.toPolyMor ff o>CoMod Sol_toPolyMor_ff'Sol) blurb));
            first by clear -grade_ff ff_Sol_transp ff'Sol_transp; abstract tac_degrade grade_ff.
        move: (projT1 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _  (Sol.toPolyMor ff o>CoMod Sol_toPolyMor_ff'Sol) blurb)))
                (projT1 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _  (Sol.toPolyMor ff o>CoMod Sol_toPolyMor_ff'Sol) blurb))))
                (projT2 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _ (Sol.toPolyMor ff o>CoMod Sol_toPolyMor_ff'Sol) blurb)))) ff_o_g_transp
        => Yoneda10_Param_ff_o_g Yoneda10_Form_ff_o_g ff_o_g ff_o_g_transp .
        clear solveCoMod solveCoMod_param.

        unshelve eexists. do 2 eexists.
        refine ( 'Forget @_ Heq_subst = param_Forget o>CoMod ff_o_g )%sol.
        move: ff_Sol_transp ff'Sol_transp ff_o_g_transp; clear;
          abstract (tac_simpl; intros; eapply convCoMod_Trans with
                 (uTrans := ( 'Forget @_ Heq_subst = (Sol.toPolyMor_param param_Forget) o>CoMod (Sol.toPolyMor ff) )
                              o>CoMod ( Sol_toPolyMor_ff'Sol )); tac_reduce).
    }

  (** ff is (ff_ o>CoMod ff') , to (ff_Sol o>CoMod ff'Sol)  ,
is (ff_Sol o>CoMod ('ViewedFunctor1 ff @_ Heq_param  = param_ff)) **)
  *  move:  (Sol.Destruct_codomViewedFunctor.morCoMod_codomViewedFunctorP ff_Sol) => ff_Sol_codomViewedFunctorP.
     { destruct ff_Sol_codomViewedFunctorP as
           [ _Yoneda00_Form_F _Yoneda01_Form_F _Yoneda00_Param_F _Yoneda01_Param_F _Yoneda10_FormParam_F _F _Param_F
           |  _Yoneda00_Form_F   _Yoneda01_Form_F   _Yoneda00_Param_F   _Yoneda01_Param_F   _Yoneda10_FormParam_F   _F _Param_F   Yoneda00_Form_E   Yoneda01_Form_E   Yoneda00_Param_E   Yoneda01_Param_E   Yoneda10_FormParam_E   E Param_E _Yoneda10_Param_ff0 _param_ff _Yoneda10_Param_ff _Yoneda10_Form_ff _ff _Heq_param
           | _Yoneda00_Form_F _Yoneda01_Form_F _Yoneda00_Param_F _Yoneda01_Param_F _Yoneda10_FormParam_F _F _Param_F Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E E _Yoneda10_Param_ff _Yoneda10_Form_ff _ff
           |  _Yoneda00_Form_F   _Yoneda01_Form_F   _Yoneda00_Param_F   _Yoneda01_Param_F   _Yoneda10_FormParam_F isFiniteness_Param_F isFiniteness_FormParam_F  Yoneda10_Param_param_   _Heq_param   Yoneda00_Form_E   Yoneda01_Form_E   Yoneda00_Param_E   Yoneda01_Param_E   Yoneda10_FormParam_E   E Param_E Yoneda10_Param_ee0 param_ee0_ Yoneda10_Param_ee Yoneda10_Form_ee _Heq_param_ee Yoneda10_Param_ee0_morphism Yoneda10_Form_ee_quotientLogical Yoneda10_Form_ee_morphism ee_
           | _Yoneda00_Form_F   _Yoneda01_Form_F   _Yoneda00_Param_F   _Yoneda01_Param_F   _Yoneda10_FormParam_F   _F   _Param_F   Yoneda00_Param_SubstF   Yoneda01_Param_SubstF   Param_SubstF   Yoneda10_Param_Forget   param_Forget Yoneda00_Form_E0   Yoneda01_Form_E0   Yoneda00_Param_E0   Yoneda01_Param_E0   Yoneda10_FormParam_E0   E0 Param_E0   Yoneda10_Param_ee   Yoneda10_Form_ee   _ff Yoneda10_Param_Forget' Heq_subst
           ] .

       (** ff is (ff_ o>CoMod ff') , to (ff_Sol o>CoMod ff'Sol)  ,
is ((@'UnitCoMod F) o>CoMod ('ViewedFunctor1 ff @_ Heq_param  = param_ff )) **)
       - unshelve eexists. do 2 eexists. refine ('ViewedFunctor1 ff @_ Heq_param  = param_ff)%sol.
         move: ff_Sol_transp ff'Sol_transp; clear;
           abstract (tac_simpl; intros; eapply convCoMod_Trans with
                                        (uTrans := ('UnitCoMod) o>CoMod ('ViewedFunctor1 (Sol.toPolyMor ff) @_ Heq_param  = (Sol.toPolyMor_param param_ff))); tac_reduce).

       (** ff is (ff_ o>CoMod ff') , to (ff_Sol o>CoMod ff'Sol)  ,
is (('ViewedFunctor1 _ff @_ _Heq_param = _param_ff) o>CoMod ('ViewedFunctor1 ff @_ Heq_param  = param_ff )) **)
       - have [:blurb] _ff_o_ff_transp :=
          (proj2_sig (solveCoMod len _ _ _ _ _ _ _ _ _ _ _ _ _ _ (Sol.toPolyMor _ff o>CoMod Sol.toPolyMor ff) blurb));
            first by clear -grade_ff ff_Sol_transp ff'Sol_transp; abstract tac_degrade grade_ff.
        move: (projT1 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _  (Sol.toPolyMor _ff o>CoMod Sol.toPolyMor ff) blurb)))
                (projT1 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _  (Sol.toPolyMor _ff o>CoMod Sol.toPolyMor ff) blurb))))
                (projT2 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _ (Sol.toPolyMor _ff o>CoMod Sol.toPolyMor ff) blurb)))) _ff_o_ff_transp
        => Yoneda10_Param__ff_o_ff Yoneda10_Form__ff_o_ff _ff_o_ff _ff_o_ff_transp .

        have [:blurbp] _param_ff_o_param_ff_transp :=
          (proj2_sig (solveCoMod_param len _ _ _  _ _ _  _ (Sol.toPolyMor_param _param_ff o>CoMod_ Sol.toPolyMor_param param_ff) blurbp));
            first by clear -grade_ff ff_Sol_transp ff'Sol_transp; abstract tac_degrade grade_ff.
        (*MEMO: OLD ERROR
          The term "Sol.toPolyMor_param _param_ff" has type "'CoMod_ ( _Param_E ~> ViewingFunctor_Param_default _Param_F @_ _Yoneda10_Param_ff0 )" while it is expected to have type
 "'CoMod_ ( _Param_E ~> Param_E @_ ?Yoneda10_Param_ff_ )" (cannot unify "ViewingFunctor_Param_default _Param_F" and "Param_E"). *)
        move:   (projT1 (sval (solveCoMod_param len _ _ _  _ _ _  _ (Sol.toPolyMor_param _param_ff o>CoMod_ Sol.toPolyMor_param param_ff) blurbp)))
                  (projT2 (sval (solveCoMod_param len _ _ _  _ _ _  _ (Sol.toPolyMor_param _param_ff o>CoMod_ Sol.toPolyMor_param param_ff) blurbp))) _param_ff_o_param_ff_transp
        => Yoneda10_Param__ff_o_ff0 _param_ff_o_param_ff _param_ff_o_param_ff_transp .
        clear solveCoMod solveCoMod_param.

        unshelve eexists. do 2 eexists.
        refine ( 'ViewedFunctor1 _ff_o_ff @_ _ = _param_ff_o_param_ff )%sol.

        (** Heq_param *)
        { clear -Heq_param _Heq_param _ff_o_ff_transp _param_ff_o_param_ff_transp.
          abstract ((move : (convCoMod_sense _ff_o_ff_transp) => _ff_o_ff_transp_eq);
                    (move: (convCoMod_sense_param _param_ff_o_param_ff_transp) => _param_ff_o_param_ff_transp_eq);
                    intros; rewrite /= (proj1 _ff_o_ff_transp_eq) _param_ff_o_param_ff_transp_eq
                                    /= -_Heq_param -Heq_param // ). }

        move: ff_Sol_transp ff'Sol_transp _ff_o_ff_transp _param_ff_o_param_ff_transp; clear;
          abstract (tac_simpl; intros; eapply convCoMod_Trans with
                 (uTrans := ( 'ViewedFunctor1 (Sol.toPolyMor _ff) @_ _Heq_param = (Sol.toPolyMor_param _param_ff) )
                              o>CoMod ( 'ViewedFunctor1 (Sol.toPolyMor ff) @_ Heq_param  = (Sol.toPolyMor_param param_ff) )); tac_reduce).

       (** ff is (ff_ o>CoMod ff') , to (ff_Sol o>CoMod ff'Sol)  ,
is ((_ff o>CoMod 'UnitViewedFunctor @_ _Param_F) o>CoMod ('ViewedFunctor1 ff @_ Heq_param  = param_ff )) **)
       - have [:blurb] _ff_o_ff_transp :=
          (proj2_sig (solveCoMod len _ _ _ _ _ _ _ _ _ _ _ _ _ _ (Sol.toPolyMor _ff o>CoMod Sol.toPolyMor ff) blurb));
            first by clear -grade_ff ff_Sol_transp ff'Sol_transp; abstract tac_degrade grade_ff.
        move: (projT1 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _  (Sol.toPolyMor _ff o>CoMod Sol.toPolyMor ff) blurb)))
                (projT1 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _  (Sol.toPolyMor _ff o>CoMod Sol.toPolyMor ff) blurb))))
                (projT2 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _ (Sol.toPolyMor _ff o>CoMod Sol.toPolyMor ff) blurb)))) _ff_o_ff_transp
        => Yoneda10_Param__ff_o_ff Yoneda10_Form__ff_o_ff _ff_o_ff _ff_o_ff_transp .
        clear solveCoMod solveCoMod_param.

        unshelve eexists. do 2 eexists.
        refine ( _ff_o_ff o>CoMod 'UnitViewedFunctor @_ Param_F )%sol.

        move: ff_Sol_transp ff'Sol_transp _ff_o_ff_transp; clear;
          abstract (tac_simpl; intros; eapply convCoMod_Trans with
                 (uTrans := ( (Sol.toPolyMor _ff) o>CoMod 'UnitViewedFunctor @_ _Param_F )
                              o>CoMod ( 'ViewedFunctor1 (Sol.toPolyMor ff) @_ Heq_param  = (Sol.toPolyMor_param param_ff) )); tac_reduce).

       (** ff is (ff_ o>CoMod ff') , to (ff_Sol o>CoMod ff'Sol)  ,
is ( [[ ee_ @_ param_ee0_ @^ _Yoneda10_FormParam_F ]] o>CoMod ('ViewedFunctor1 ff @_ Heq_param  = param_ff )) **)
       - have [:blurb_] ee_o_ff_transp G param form :=
           (proj2_sig (solveCoMod len _ _ _ _ _ _ _ _ _ _ _ _ _ _
                    ((Sol.toPolyMor (ee_(G)(param)(form))) o>CoMod Sol.toPolyMor ff) (blurb_ G param form)));
             first by clear -grade_ff ff_Sol_transp ff'Sol_transp;
             abstract((move => G param form);
                      match goal with
                      | [ isFiniteness_Param_F : Finiteness.isFiniteness_Param_ _Yoneda01_Param_F ,
                          isFiniteness_FormParam_F : Finiteness.isFiniteness_FormParam_ _Yoneda10_FormParam_F  |- _ ] =>
                        destruct (Finiteness.is_viewingFunctorParamElement12_allP isFiniteness_Param_F param);
                        destruct (Finiteness.is_viewingFunctorElement12_allP isFiniteness_FormParam_F form)
                      end; tac_degrade grade_ff).
         have @Yoneda10_Param_ee_o_ff_ :=
           (fun G param form => projT1 (sval (solveCoMod len _ _ _ _ _ _ _ _ _ _ _ _ _ _
                     ((Sol.toPolyMor (ee_(G)(param)(form))) o>CoMod Sol.toPolyMor ff) (blurb_ G param form)))).
         have @Yoneda10_Form_ee_o_ff_ :
           (forall G param form, Yoneda10_Form_data (Yoneda10_FormParam_View G) Yoneda10_FormParam_F (Yoneda10_Param_ee_o_ff_ G param form) )
           := (fun G param form => projT1 (projT2 (sval (solveCoMod len _ _ _ _ _ _ _ _ _ _ _ _ _ _
                    ((Sol.toPolyMor (ee_(G)(param)(form))) o>CoMod Sol.toPolyMor ff) (blurb_ G param form))))).
         have @ee_o_ff_ :
           (forall G param form,  'CoMod( View G ~> F
                                  @_ Yoneda10_Param_ee_o_ff_ G param form @^ Yoneda10_Form_ee_o_ff_ G param form ) %sol)
           := (fun G param form => projT2 (projT2 (sval (solveCoMod len _ _ _ _ _ _ _ _ _ _ _ _ _ _
                        ((Sol.toPolyMor (ee_(G)(param)(form))) o>CoMod Sol.toPolyMor ff) (blurb_ G param form))))) .
         have {ee_o_ff_transp}:
           (forall G param form, Sol.toPolyMor (ee_o_ff_(G)(param)(form))
                      <~~ (Sol.toPolyMor (ee_(G)(param)(form))) o>CoMod Sol.toPolyMor ff) := ee_o_ff_transp.
         move: Yoneda10_Param_ee_o_ff_ Yoneda10_Form_ee_o_ff_ ee_o_ff_
         => Yoneda10_Param_ee_o_ff_ Yoneda10_Form_ee_o_ff_ ee_o_ff_ ee_o_ff_transp.

         have [:blurbp_] param_ee0_o_param_ff_transp G param :=
           (proj2_sig (solveCoMod_param len _ _ _  _ _ _  _
            ((Sol.toPolyMor_param (param_ee0_(G)(param))) o>CoMod_ Sol.toPolyMor_param param_ff) (blurbp_ G param)));
             first by clear -grade_ff ff_Sol_transp ff'Sol_transp;
             abstract((move => G param);
                      match goal with
                      | [ isFiniteness_Param_F : Finiteness.isFiniteness_Param_ _Yoneda01_Param_F  |- _ ] =>
                        destruct (Finiteness.is_viewingFunctorParamElement12_allP isFiniteness_Param_F param)
                      end; tac_degrade grade_ff).
         have @Yoneda10_param_ee0_o_param_ff_ :=
           (fun G param => projT1 (sval (solveCoMod_param len _ _ _  _ _ _  _
             ((Sol.toPolyMor_param (param_ee0_(G)(param))) o>CoMod_ Sol.toPolyMor_param param_ff) (blurbp_ G param)))).
         have @param_ee0_o_param_ff_ :
           (forall G param, 'CoMod_( View_Param (Parameter0 G) ~> Param_F @_ Yoneda10_param_ee0_o_param_ff_ G param ) %sol)
           := (fun G param => (projT2 (sval (solveCoMod_param len _ _ _  _ _ _  _
             ((Sol.toPolyMor_param (param_ee0_(G)(param))) o>CoMod_ Sol.toPolyMor_param param_ff) (blurbp_ G param))))) .
         have {param_ee0_o_param_ff_transp}:
           (forall G param, Sol.toPolyMor_param (param_ee0_o_param_ff_(G)(param)) <~~_ (Sol.toPolyMor_param (param_ee0_(G)(param))) o>CoMod_ Sol.toPolyMor_param param_ff) := param_ee0_o_param_ff_transp.
         move: Yoneda10_param_ee0_o_param_ff_ param_ee0_o_param_ff_ =>
         Yoneda10_param_ee0_o_param_ff_ param_ee0_o_param_ff_ param_ee0_o_param_ff_transp.
         clear solveCoMod solveCoMod_param.

         unshelve eexists. do 2 eexists.
         refine ( [[  ee_o_ff_  @_ param_ee0_o_param_ff_ , isFiniteness_Param_F , _Heq_param , _ , _  @^ isFiniteness_FormParam_F , _ , _  ]] %sol ).

         (** Heq_param_ee *)
         { clear -_Heq_param_ee Heq_param ee_o_ff_transp param_ee0_o_param_ff_transp;
           abstract ((move : (fun G param form => convCoMod_sense (ee_o_ff_transp G param form)) => ee_o_ff_transp_eq);
                     (move: (fun G param => convCoMod_sense_param (param_ee0_o_param_ff_transp G param)) => param_ee0_o_param_ff_transp_eq);
                     intros; simpl; rewrite (proj1 (ee_o_ff_transp_eq _ _ _)) (param_ee0_o_param_ff_transp_eq _ _)
                                            /= -Heq_param (_Heq_param_ee) // ).
         }
         (** Yoneda10_Param_ee0_morphism *)
         { clear -Yoneda10_Param_ee0_morphism Heq_param param_ee0_o_param_ff_transp;
           abstract ((move: (fun G param => convCoMod_sense_param (param_ee0_o_param_ff_transp G param))
                      => param_ee0_o_param_ff_transp_eq);
                     intros; do 2 rewrite (param_ee0_o_param_ff_transp_eq _ _) /= -Heq_param;
                     congr (sval Yoneda10_Param_ff _); exact: Yoneda10_Param_ee0_morphism).
         }
         (** Yoneda10_Form_ee_quotientLogical *)
         { clear -Yoneda10_Form_ee_quotientLogical ee_o_ff_transp.
           abstract ((move : (fun G param form => convCoMod_sense (ee_o_ff_transp G param form)) => ee_o_ff_transp_eq);
                     intros; do 2 rewrite (proj2 (ee_o_ff_transp_eq _ _ _)) /= ;
                     apply: (proj2 (proj2_sig Yoneda10_Form_ff));
                     exact: Yoneda10_Form_ee_quotientLogical).
         }
         (** Yoneda10_Form_ee_morphism *)
         { clear -Yoneda10_Form_ee_morphism ee_o_ff_transp.
           abstract((move : (fun G param form => convCoMod_sense (ee_o_ff_transp G param form)) => ee_o_ff_transp_eq);
                    intros; do 2 rewrite (proj2 (ee_o_ff_transp_eq _ _ _)) /=;
                apply: (proj2 (proj2_sig Yoneda10_Form_ff)) (**MEMO: /!\ this comparable to congr for param /!\*);
                    exact: Yoneda10_Form_ee_morphism).
         }

         move: ff_Sol_transp ff'Sol_transp ee_o_ff_transp param_ee0_o_param_ff_transp; clear;
           abstract (tac_simpl; intros; eapply convCoMod_Trans with
                 (uTrans := ( [[ (fun G param form => (Sol.toPolyMor (ee_(G)(param)(form))))
                                   @_ (fun G param => (Sol.toPolyMor_param (param_ee0_(G)(param))))
                                 , isFiniteness_Param_F , _Heq_param , _Heq_param_ee , Yoneda10_Param_ee0_morphism
                                   @^ isFiniteness_FormParam_F , Yoneda10_Form_ee_quotientLogical , Yoneda10_Form_ee_morphism ]] )
                              o>CoMod ( 'ViewedFunctor1 (Sol.toPolyMor ff) @_ Heq_param  = (Sol.toPolyMor_param param_ff) )); tac_reduce).

       (** ff is (ff_ o>CoMod ff') , to (ff_Sol o>CoMod ff'Sol)  ,
is (('Forget @_ Heq_subst = param_Forget o>CoMod _ff) o>CoMod ('ViewedFunctor1 ff @_ Heq_param  = param_ff )) **)
       - pose Sol_toPolyMor_ff'Sol := ('ViewedFunctor1 (Sol.toPolyMor ff) @_ Heq_param  = (Sol.toPolyMor_param param_ff)).
         have [:blurb] _ff_o_ff'Sol_transp :=
          (proj2_sig (solveCoMod len _ _ _ _ _ _ _ _ _ _ _ _ _ _ (Sol.toPolyMor _ff o>CoMod Sol_toPolyMor_ff'Sol) blurb));
            first by clear -grade_ff ff_Sol_transp ff'Sol_transp; abstract tac_degrade grade_ff.
        move: (projT1 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _  (Sol.toPolyMor _ff o>CoMod Sol_toPolyMor_ff'Sol) blurb)))
                (projT1 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _  (Sol.toPolyMor _ff o>CoMod Sol_toPolyMor_ff'Sol) blurb))))
                (projT2 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _ (Sol.toPolyMor _ff o>CoMod Sol_toPolyMor_ff'Sol) blurb)))) _ff_o_ff'Sol_transp
        => Yoneda10_Param__ff_o_ff'Sol Yoneda10_Form__ff_o_ff'Sol _ff_o_ff'Sol _ff_o_ff'Sol_transp .
        clear solveCoMod solveCoMod_param.

        unshelve eexists. do 2 eexists.
        refine ( 'Forget @_ Heq_subst = param_Forget o>CoMod _ff_o_ff'Sol )%sol.

        move: ff_Sol_transp ff'Sol_transp _ff_o_ff'Sol_transp; clear;
          abstract (tac_simpl; intros; eapply convCoMod_Trans with
                 (uTrans := ( 'Forget @_ Heq_subst = (Sol.toPolyMor_param param_Forget) o>CoMod (Sol.toPolyMor _ff) )
                              o>CoMod Sol_toPolyMor_ff'Sol); tac_reduce).
     }

  (** ff is (ff_ o>CoMod ff') , to (ff_Sol o>CoMod ff'Sol)  ,
is (ff_Sol o>CoMod (ff o>CoMod 'UnitViewedFunctor @_ Param_F)) **)
  * have [:blurb] ff_Sol_o_ff_transp :=
      (proj2_sig (solveCoMod len _ _ _ _ _ _ _ _ _ _ _ _ _ _ (Sol.toPolyMor ff_Sol o>CoMod Sol.toPolyMor ff) blurb));
        first by clear -grade_ff ff_Sol_transp ff'Sol_transp; abstract tac_degrade grade_ff.
    move: (projT1 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _
                                    (Sol.toPolyMor ff_Sol o>CoMod Sol.toPolyMor ff) blurb)))
            (projT1 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _
                                              (Sol.toPolyMor ff_Sol o>CoMod Sol.toPolyMor ff) blurb))))
            (projT2 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _
                                              (Sol.toPolyMor ff_Sol o>CoMod Sol.toPolyMor ff) blurb)))) ff_Sol_o_ff_transp
        => Yoneda10_Param_ff_Sol_o_ff Yoneda10_Form_ff_Sol_o_ff ff_Sol_o_ff ff_Sol_o_ff_transp .
    clear solveCoMod solveCoMod_param.

    unshelve eexists. do 2 eexists.
    refine ( ff_Sol_o_ff o>CoMod 'UnitViewedFunctor @_ Param_F )%sol.
    move: ff_Sol_transp ff'Sol_transp ff_Sol_o_ff_transp; clear;
    abstract (tac_simpl; intros; eapply convCoMod_Trans with
                  (uTrans := ( Sol.toPolyMor ff_Sol )
                     o>CoMod ( (Sol.toPolyMor ff) o>CoMod 'UnitViewedFunctor @_ Param_F )); tac_reduce).

  (** ff is (ff_ o>CoMod ff') , to (ff_Sol o>CoMod ff'Sol)  ,
is (ff_Sol o>CoMod ('PolyElement form @_ isFiniteness_Param_F , Heq_param , Yoneda10_Param_param_morphism @^ isFiniteness_FormParam_F)) **)
  *  move:  (Sol.Destruct_codomView.morCoMod_codomViewP ff_Sol) => ff_Sol_codomViewP.
     { destruct ff_Sol_codomViewP as
          [ G
          | G H g
          | _Yoneda00_Form_F _Yoneda01_Form_F _Yoneda00_Param_F _Yoneda01_Param_F _Yoneda10_FormParam_F _F Param_F Yoneda00_Param_SubstF Yoneda01_Param_SubstF Param_SubstF Yoneda10_Param_Forget param_Forget Yoneda10_Param_Forget' Heq_subst _G Yoneda10_Param_ee Yoneda10_Form_ee ff].

       (** ff is (ff_ o>CoMod ff') , to (ff_Sol o>CoMod ff'Sol)  ,
is (( @'UnitCoMod (View G) ) o>CoMod ('PolyElement form @_ isFiniteness_Param_F , Heq_param , Yoneda10_Param_param_morphism @^ isFiniteness_FormParam_F)) **)
       - unshelve eexists. do 2 eexists. refine ('PolyElement form @_ isFiniteness_Param_F , Heq_param , Yoneda10_Param_param_morphism @^ isFiniteness_FormParam_F)%sol.
         move: ff_Sol_transp ff'Sol_transp; clear;
           abstract (tac_simpl; intros; eapply convCoMod_Trans with
                                        (uTrans := ('UnitCoMod) o>CoMod ('PolyElement form @_ isFiniteness_Param_F , Heq_param , Yoneda10_Param_param_morphism @^ isFiniteness_FormParam_F)); tac_reduce).

       (** ff is (ff_ o>CoMod ff') , to (ff_Sol o>CoMod ff'Sol)  ,
is (( 'View1 g ) o>CoMod ('PolyElement form @_ isFiniteness_Param_F , Heq_param , Yoneda10_Param_param_morphism @^ isFiniteness_FormParam_F)) **)
       - unshelve eexists. do 2 eexists. refine ('PolyElement ( g o>GeneratorAtParam_[sval (Yoneda01_AtParam_ Yoneda10_FormParam_F)] form ) @_ isFiniteness_Param_F , Heq_param , Yoneda10_Param_param_morphism @^ isFiniteness_FormParam_F)%sol.
         move: ff_Sol_transp ff'Sol_transp; clear;
           abstract (tac_simpl; intros; eapply convCoMod_Trans with
                                        (uTrans := ( 'View1 g ) o>CoMod ('PolyElement form @_ isFiniteness_Param_F , Heq_param , Yoneda10_Param_param_morphism @^ isFiniteness_FormParam_F)); tac_reduce).

       (** ff is (ff_ o>CoMod ff') , to (ff_Sol o>CoMod ff'Sol)  ,
is (( 'Forget @_ Heq_subst = param_Forget o>CoMod ff ) o>CoMod ('PolyElement form @_ isFiniteness_Param_F , Heq_param , Yoneda10_Param_param_morphism @^ isFiniteness_FormParam_F)) **)
       - pose Sol_toPolyMor_ff'Sol := ('PolyElement form @_ isFiniteness_Param_F , Heq_param , Yoneda10_Param_param_morphism @^ isFiniteness_FormParam_F).
         have [:blurb] ff_o_ff'Sol_transp :=
          (proj2_sig (solveCoMod len _ _ _ _ _ _ _ _ _ _ _ _ _ _ (Sol.toPolyMor ff o>CoMod Sol_toPolyMor_ff'Sol) blurb));
            first by clear -grade_ff ff_Sol_transp ff'Sol_transp; abstract tac_degrade grade_ff.
        move: (projT1 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _  (Sol.toPolyMor ff o>CoMod Sol_toPolyMor_ff'Sol) blurb)))
                (projT1 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _  (Sol.toPolyMor ff o>CoMod Sol_toPolyMor_ff'Sol) blurb))))
                (projT2 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _ (Sol.toPolyMor ff o>CoMod Sol_toPolyMor_ff'Sol) blurb)))) ff_o_ff'Sol_transp
        => Yoneda10_Param_ff_o_ff'Sol Yoneda10_Form_ff_o_ff'Sol ff_o_ff'Sol ff_o_ff'Sol_transp .
        clear solveCoMod solveCoMod_param.

        unshelve eexists. do 2 eexists.
        refine ( 'Forget @_ Heq_subst = param_Forget o>CoMod ff_o_ff'Sol )%sol.
        move: ff_Sol_transp ff'Sol_transp ff_o_ff'Sol_transp; clear;
          abstract (tac_simpl; intros; eapply convCoMod_Trans with
                 (uTrans := ( 'Forget @_ Heq_subst = (Sol.toPolyMor_param param_Forget) o>CoMod (Sol.toPolyMor ff) )
                              o>CoMod Sol_toPolyMor_ff'Sol); tac_reduce).
     }

  (** ff is (ff_ o>CoMod ff') , to (ff_Sol o>CoMod ff'Sol)  ,
is (ff_Sol o>CoMod ( [[  ee_  @_ param_ee0_ , isFiniteness_Param_F , Heq_param , Heq_param_ee , Yoneda10_Param_ee0_morphism  @^ isFiniteness_FormParam_F , Yoneda10_Form_ee_quotientLogical , Yoneda10_Form_ee_morphism  ]] )) **)
  * move:  (Sol.Destruct_codomViewingFunctor.morCoMod_codomViewingFunctorP ff_Sol) => ff_Sol_codomViewingFunctorP.
    { destruct ff_Sol_codomViewingFunctorP as
          [ Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F isFiniteness_Param_F isFiniteness_FormParam_F
          | Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F isFiniteness_Param_F isFiniteness_FormParam_F x_Yoneda10_Param_param_ _Heq_param Yoneda10_Param_param_morphism G param form
          |  Yoneda00_Form_F Yoneda01_Form_F   Yoneda00_Param_F   Yoneda01_Param_F   Yoneda10_FormParam_F  F   Param_F   Yoneda00_Param_SubstF   Yoneda01_Param_SubstF   Param_SubstF   Yoneda10_Param_Forget   param_Forget Yoneda10_Param_Forget' Heq_subst   Yoneda00_Form_E0   Yoneda01_Form_E0   Yoneda00_Param_E0   Yoneda01_Param_E0   Yoneda10_FormParam_E0 isFiniteness_Param_E0 isFiniteness_FormParam_E0  _Yoneda10_Param_ee   _Yoneda10_Form_ee   ff
          ] .

      (** ff is (ff_ o>CoMod ff') , to (ff_Sol o>CoMod ff'Sol)  ,
is (('UnitCoMod) o>CoMod ( [[ ee_ @_ param_ee0_ @^ isFiniteness_FormParam_F ]] )) **)
      - unshelve eexists. do 2 eexists. refine ( [[  ee_  @_ param_ee0_ , isFiniteness_Param_F , Heq_param , Heq_param_ee , Yoneda10_Param_ee0_morphism  @^ isFiniteness_FormParam_F , Yoneda10_Form_ee_quotientLogical , Yoneda10_Form_ee_morphism  ]] )%sol.
        move: ff_Sol_transp ff'Sol_transp; clear;
          abstract (tac_simpl; intros; eapply convCoMod_Trans with
                (uTrans := ('UnitCoMod) o>CoMod ( [[  (fun G param form => Sol.toPolyMor (ee_(G)(param)(form)))  @_ (fun G param => Sol.toPolyMor_param (param_ee0_(G)(param))) , isFiniteness_Param_F , Heq_param , Heq_param_ee , Yoneda10_Param_ee0_morphism  @^ isFiniteness_FormParam_F , Yoneda10_Form_ee_quotientLogical , Yoneda10_Form_ee_morphism  ]] )); tac_reduce).

        (** ff is (ff_ o>CoMod ff') , to (ff_Sol o>CoMod ff'Sol)  ,
is (('PolyElement form @_ isFiniteness_Param_F , _Heq_param, Yoneda10_Param_param_morphism @^ isFiniteness_FormParam_F) o>CoMod ( [[ ee_ @_ param_ee0_ @^ isFiniteness_FormParam_F ]] )) **)
      - unshelve eexists. do 2 eexists.
        refine ( (ee_(G)(param)(form)) o>CoMod 'UnitViewedFunctor @_ Param_E )%sol.
        move: ff_Sol_transp ff'Sol_transp; clear;
        abstract (tac_simpl; intros; eapply convCoMod_Trans with
                (uTrans := ( 'PolyElement form @_ isFiniteness_Param_F , _Heq_param, Yoneda10_Param_param_morphism @^ isFiniteness_FormParam_F ) o>CoMod ( [[  (fun G param form => Sol.toPolyMor (ee_(G)(param)(form)))  @_ (fun G param => Sol.toPolyMor_param (param_ee0_(G)(param))) , isFiniteness_Param_F , Heq_param , Heq_param_ee , Yoneda10_Param_ee0_morphism  @^ isFiniteness_FormParam_F , Yoneda10_Form_ee_quotientLogical , Yoneda10_Form_ee_morphism  ]] )); tac_reduce).

      (** ff is (ff_ o>CoMod ff') , to (ff_Sol o>CoMod ff'Sol)  ,
is (('Forget @_ Heq_subst = param_Forget o>CoMod ff) o>CoMod ( [[ ee_ @_ param_ee0_ @^ isFiniteness_FormParam_E0 ]] )) **)
      - pose Sol_toPolyMor_ff'Sol := ( [[  (fun G param form => Sol.toPolyMor (ee_(G)(param)(form)))  @_ (fun G param => Sol.toPolyMor_param (param_ee0_(G)(param))) , isFiniteness_Param_E0 , Heq_param , Heq_param_ee , Yoneda10_Param_ee0_morphism  @^ isFiniteness_FormParam_E0 , Yoneda10_Form_ee_quotientLogical , Yoneda10_Form_ee_morphism  ]] ).
         have [:blurb] ff_o_ff'Sol_transp :=
          (proj2_sig (solveCoMod len _ _ _ _ _ _ _ _ _ _ _ _ _ _ (Sol.toPolyMor ff o>CoMod Sol_toPolyMor_ff'Sol) blurb));
            first by clear -grade_ff ff_Sol_transp ff'Sol_transp; abstract tac_degrade grade_ff.
        move: (projT1 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _  (Sol.toPolyMor ff o>CoMod Sol_toPolyMor_ff'Sol) blurb)))
                (projT1 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _  (Sol.toPolyMor ff o>CoMod Sol_toPolyMor_ff'Sol) blurb))))
                (projT2 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _ (Sol.toPolyMor ff o>CoMod Sol_toPolyMor_ff'Sol) blurb)))) ff_o_ff'Sol_transp
        => Yoneda10_Param_ff_o_ff'Sol Yoneda10_Form_ff_o_ff'Sol ff_o_ff'Sol ff_o_ff'Sol_transp .
        clear solveCoMod solveCoMod_param.

        unshelve eexists. do 2 eexists.
        refine ( 'Forget @_ Heq_subst = param_Forget o>CoMod ff_o_ff'Sol )%sol.
        move: ff_Sol_transp ff'Sol_transp ff_o_ff'Sol_transp; clear;
          abstract (tac_simpl; intros; eapply convCoMod_Trans with
                 (uTrans := ( 'Forget @_ Heq_subst = (Sol.toPolyMor_param param_Forget) o>CoMod (Sol.toPolyMor ff) )
                              o>CoMod Sol_toPolyMor_ff'Sol); tac_reduce).
    }

  (** ff is (ff_ o>CoMod ff') , to (ff_Sol o>CoMod ff'Sol)  ,
is (ff_Sol o>CoMod ( 'Forget @_ Heq_subst = param_Forget o>CoMod ee )) **)
  * move:  (Sol.Destruct_codomSubst.morCoMod_codomSubstP ff_Sol) => ff_Sol_codomSubstP.
    { destruct ff_Sol_codomSubstP as
          [ Yoneda01_Form_F    Yoneda00_Param_F    Yoneda01_Param_F    Yoneda10_FormParam_F    F Param_F   Yoneda00_Param_SubstF    Yoneda01_Param_SubstF  Param_SubstF    Yoneda10_Param_subst
          | Yoneda00_Form_F    Yoneda01_Form_F    Yoneda00_Param_F    Yoneda01_Param_F    Yoneda10_FormParam_F    F    _Param_F    Yoneda00_Param_SubstF    Yoneda01_Param_SubstF    Param_SubstF    _Yoneda10_Param_Forget    _param_Forget  Yoneda10_Param_Forget'  _Heq_subst    Yoneda00_Form_E0    Yoneda01_Form_E0    Yoneda00_Param_E0    Yoneda01_Param_E0    Yoneda10_FormParam_E0    E0  Param_E0  Yoneda00_Param_SubstE0    Yoneda01_Param_SubstE0  Param_SubstE0    Yoneda10_Param_subst    _Yoneda10_Param_ee    _Yoneda10_Form_ee    ff
          |  Yoneda00_Form_F    Yoneda01_Form_F    Yoneda00_Param_F    Yoneda01_Param_F    Yoneda10_FormParam_F    F    _Param_F    Yoneda00_Param_SubstF    Yoneda01_Param_SubstF    Param_SubstF    _Yoneda10_Param_Forget    _param_Forget L  Yoneda10_Param_ll    Yoneda10_Form_ll ff Yoneda10_Param_ll_  Heq_param Yoneda10_Param_Forget'  _Heq_subst
          ] .

      (** ff is (ff_ o>CoMod ff') , to (ff_Sol o>CoMod ff'Sol)  ,
is (('UnitCoMod) o>CoMod ( 'Forget @_ Heq_subst = param_Forget o>CoMod ee )) **)
      - unshelve eexists. do 2 eexists. refine ( 'Forget @_ Heq_subst = param_Forget o>CoMod ee )%sol.
        move: ff_Sol_transp ff'Sol_transp; clear;
          abstract (tac_simpl; intros; eapply convCoMod_Trans with
                                       (uTrans := ('UnitCoMod) o>CoMod ( 'Forget @_ Heq_subst = (Sol.toPolyMor_param param_Forget) o>CoMod (Sol.toPolyMor ee) )); tac_reduce).

      (** ff is (ff_ o>CoMod ff') , to (ff_Sol o>CoMod ff'Sol)  ,
is (('Forget @_ _Heq_subst = _param_Forget o>CoMod ff) o>CoMod ( 'Forget @_ Heq_subst = param_Forget o>CoMod ee )) **)
      - pose Sol_toPolyMor_ff'Sol := ( 'Forget @_ Heq_subst = (Sol.toPolyMor_param param_Forget) o>CoMod (Sol.toPolyMor ee) ).
         have [:blurb] ff_o_ff'Sol_transp :=
          (proj2_sig (solveCoMod len _ _ _ _ _ _ _ _ _ _ _ _ _ _ (Sol.toPolyMor ff o>CoMod Sol_toPolyMor_ff'Sol) blurb));
            first by clear -grade_ff ff_Sol_transp ff'Sol_transp; abstract tac_degrade grade_ff.
        move: (projT1 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _  (Sol.toPolyMor ff o>CoMod Sol_toPolyMor_ff'Sol) blurb)))
                (projT1 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _  (Sol.toPolyMor ff o>CoMod Sol_toPolyMor_ff'Sol) blurb))))
                (projT2 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _ (Sol.toPolyMor ff o>CoMod Sol_toPolyMor_ff'Sol) blurb)))) ff_o_ff'Sol_transp
        => Yoneda10_Param_ff_o_ff'Sol Yoneda10_Form_ff_o_ff'Sol ff_o_ff'Sol ff_o_ff'Sol_transp .
        clear solveCoMod solveCoMod_param.

        unshelve eexists. do 2 eexists.
        refine ( 'Forget @_ _Heq_subst = _param_Forget o>CoMod ff_o_ff'Sol )%sol.
        move: ff_Sol_transp ff'Sol_transp ff_o_ff'Sol_transp; clear;
          abstract (tac_simpl; intros; eapply convCoMod_Trans with
                 (uTrans := ( 'Forget @_ _Heq_subst = (Sol.toPolyMor_param _param_Forget) o>CoMod (Sol.toPolyMor ff) )
                              o>CoMod Sol_toPolyMor_ff'Sol); tac_reduce).

      (** ff is (ff_ o>CoMod ff') , to (ff_Sol o>CoMod ff'Sol)  ,
is (( << ff @_ Heq_param  = Yoneda10_Param_ll_ , _Heq_subst = _param_Forget >> ) o>CoMod ( 'Forget @_ Heq_subst = param_Forget o>CoMod ee )) **)
      - have [:blurb] ff_o_ee_transp :=
          (proj2_sig (solveCoMod len _ _ _ _ _ _ _ _ _ _ _ _ _ _ (Sol.toPolyMor ff o>CoMod Sol.toPolyMor ee) blurb));
            first by clear -grade_ff ff_Sol_transp ff'Sol_transp; abstract tac_degrade grade_ff.
        (*MEMO:  /!\ HOHOHO FEINTE /!\ OLD ERROR:
         The term "Sol.toPolyMor ff" has type "'CoMod ( L ~> ViewedFunctor_default F _Param_F @_ Yoneda10_Param_ll @^ Yoneda10_Form_ll )" while it is expected to have type
 "'CoMod ( L ~> ViewedFunctor_default F Param_F @_ ?Yoneda10_Param_ff_ @^ ?Yoneda10_Form_ff_ )" (cannot unify "ViewedFunctor_default F _Param_F" and "ViewedFunctor_default F Param_F"). **)
        move: (projT1 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _
                                    (Sol.toPolyMor ff o>CoMod Sol.toPolyMor ee) blurb)))
            (projT1 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _
                                              (Sol.toPolyMor ff o>CoMod Sol.toPolyMor ee) blurb))))
            (projT2 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _
                                              (Sol.toPolyMor ff o>CoMod Sol.toPolyMor ee) blurb)))) ff_o_ee_transp
        => Yoneda10_Param_ff_o_ee Yoneda10_Form_ff_o_ee ff_o_ee ff_o_ee_transp .
        clear solveCoMod solveCoMod_param.

        unshelve eexists. do 2 eexists. refine ( ff_o_ee )%sol.
        move: ff_Sol_transp ff'Sol_transp ff_o_ee_transp; clear;
          abstract (tac_simpl; intros; eapply convCoMod_Trans with
                                     (uTrans := ( << (Sol.toPolyMor ff) @_ Heq_param  = Yoneda10_Param_ll_ , _Heq_subst = (Sol.toPolyMor_param _param_Forget) >> )
                               o>CoMod ( 'Forget @_ Heq_subst = (Sol.toPolyMor_param param_Forget) o>CoMod (Sol.toPolyMor ee) )); tac_reduce).
    }

  (** ff is (ff_ o>CoMod ff') , to (ff_Sol o>CoMod ff'Sol)  ,
is (ff_Sol o>CoMod ( << ll @_ Heq_param  = Yoneda10_Param_ll_ , Heq_subst = param_Forget >> )) **)
  * move: (Sol.Destruct_codomView.morCoMod_codomViewP ff_Sol) => ff_Sol_codomViewP.
    { destruct ff_Sol_codomViewP as
          [ G
          | G H g
          | _Yoneda00_Form_F _Yoneda01_Form_F _Yoneda00_Param_F _Yoneda01_Param_F _Yoneda10_FormParam_F _F _Param_F _Yoneda00_Param_SubstF _Yoneda01_Param_SubstF _Param_SubstF _Yoneda10_Param_Forget _param_Forget _Yoneda10_Param_Forget' _Heq_subst _G Yoneda10_Param_ee Yoneda10_Form_ee ff].

      (** ff is (ff_ o>CoMod ff') , to (ff_Sol o>CoMod ff'Sol)  ,
is (( @'UnitCoMod (View G) ) o>CoMod ( << ll @_ Heq_param  = Yoneda10_Param_ll_ , Heq_subst = param_Forget >> )) **)
      - unshelve eexists. do 2 eexists. refine ( << ll @_ Heq_param  = Yoneda10_Param_ll_ , Heq_subst = param_Forget >> )%sol.
        move: ff_Sol_transp ff'Sol_transp; clear;
          abstract (tac_simpl; intros; eapply convCoMod_Trans with
                                       (uTrans := ('UnitCoMod) o>CoMod ( << (Sol.toPolyMor ll) @_ Heq_param  = Yoneda10_Param_ll_ , Heq_subst = (Sol.toPolyMor_param param_Forget) >> )); tac_reduce).

      (** ff is (ff_ o>CoMod ff') , to (ff_Sol o>CoMod ff'Sol)  ,
is (( 'View1 g ) o>CoMod ( << ll @_ Heq_param  = Yoneda10_Param_ll_ , Heq_subst = param_Forget >> )) **)
      - pose Sol_toPolyMor_ff_Sol := ( 'View1 g ).
        have [:blurb] g_o_ll_transp :=
          (proj2_sig (solveCoMod len _ _ _ _ _ _ _ _ _ _ _ _ _ _ (Sol_toPolyMor_ff_Sol o>CoMod Sol.toPolyMor ll) blurb));
            first by clear -grade_ff ff_Sol_transp ff'Sol_transp; abstract tac_degrade grade_ff.
        move: (projT1 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _  (Sol_toPolyMor_ff_Sol o>CoMod Sol.toPolyMor ll) blurb)))
                (projT1 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _  (Sol_toPolyMor_ff_Sol o>CoMod Sol.toPolyMor ll) blurb))))
                (projT2 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _ (Sol_toPolyMor_ff_Sol o>CoMod Sol.toPolyMor ll) blurb)))) g_o_ll_transp
        => Yoneda10_Param_g_o_ll Yoneda10_Form_g_o_ll g_o_ll g_o_ll_transp .
        clear solveCoMod solveCoMod_param.

        unshelve eexists. do 2 eexists.
        refine ( << g_o_ll  @_ _
                 = (Yoneda10_Param_PolyCoMod (Yoneda10_Param_View1 (Parameter1 g)) Yoneda10_Param_ll_) , Heq_subst = param_Forget >> )%sol.

        (** Heq_param *)
        { clear -Heq_param g_o_ll_transp.
          abstract ((move : (convCoMod_sense g_o_ll_transp) => g_o_ll_transp_eq);
                    intros; simpl; rewrite (proj1 g_o_ll_transp_eq) /=  Heq_param; reflexivity).
        }
        move: ff_Sol_transp ff'Sol_transp g_o_ll_transp; clear;
          abstract (tac_simpl; intros; eapply convCoMod_Trans with
                                           (uTrans := ( Sol.toPolyMor (( 'View1 g )%sol) )
                                                        o>CoMod ( << (Sol.toPolyMor ll) @_ Heq_param  = Yoneda10_Param_ll_ , Heq_subst = (Sol.toPolyMor_param param_Forget) >> )); tac_reduce).

      (** ff is (ff_ o>CoMod ff') , to (ff_Sol o>CoMod ff'Sol)  ,
is (( 'Forget @_ _param_Forget o>CoMod ff ) o>CoMod ( << ll @_ Heq_param  = Yoneda10_Param_ll_ , Heq_subst = param_Forget >> )) **)
      - pose Sol_toPolyMor_ff'Sol := ( << (Sol.toPolyMor ll) @_ Heq_param  = Yoneda10_Param_ll_ , Heq_subst = (Sol.toPolyMor_param param_Forget) >> ).
         have [:blurb] ff_o_ff'Sol_transp :=
          (proj2_sig (solveCoMod len _ _ _ _ _ _ _ _ _ _ _ _ _ _ (Sol.toPolyMor ff o>CoMod Sol_toPolyMor_ff'Sol) blurb));
            first by clear -grade_ff ff_Sol_transp ff'Sol_transp; abstract tac_degrade grade_ff.
        move: (projT1 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _  (Sol.toPolyMor ff o>CoMod Sol_toPolyMor_ff'Sol) blurb)))
                (projT1 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _  (Sol.toPolyMor ff o>CoMod Sol_toPolyMor_ff'Sol) blurb))))
                (projT2 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _ (Sol.toPolyMor ff o>CoMod Sol_toPolyMor_ff'Sol) blurb)))) ff_o_ff'Sol_transp
        => Yoneda10_Param_ff_o_ff'Sol Yoneda10_Form_ff_o_ff'Sol ff_o_ff'Sol ff_o_ff'Sol_transp .
        clear solveCoMod solveCoMod_param.

        unshelve eexists. do 2 eexists.
        refine ( 'Forget @_ _Heq_subst = _param_Forget o>CoMod ff_o_ff'Sol )%sol.
        move: ff_Sol_transp ff'Sol_transp ff_o_ff'Sol_transp; clear;
          abstract (tac_simpl; intros; eapply convCoMod_Trans with
                 (uTrans := ( 'Forget @_ _Heq_subst = (Sol.toPolyMor_param _param_Forget) o>CoMod (Sol.toPolyMor ff) )
                              o>CoMod Sol_toPolyMor_ff'Sol); tac_reduce).
    }
}
(** ----- *)

{ (** solveCoMod_param **) case : len => [ | len ].

(** len is O **)
-  intros Yoneda00_Param_E Yoneda01_Param_E Param_E Yoneda00_Param_F Yoneda01_Param_F Param_F Yoneda10_Param_ff param_ff grade_param_ff; exfalso;
    clear - grade_param_ff; abstract tac_degrade grade_param_ff.

(** len is (S len) **)
- intros Yoneda00_Param_E Yoneda01_Param_E Param_E Yoneda00_Param_F Yoneda01_Param_F Param_F Yoneda10_Param_ff param_ff.
  case: Yoneda00_Param_E Yoneda01_Param_E Param_E Yoneda00_Param_F Yoneda01_Param_F Param_F Yoneda10_Param_ff / param_ff;
  [ intros Yoneda00_Param_F Yoneda01_Param_F Param_F Yoneda00_Param_F' Yoneda01_Param_F' Param_F' Yoneda10_Param_ff' param_ff'  Yoneda00_Param_F'' Yoneda01_Param_F'' Param_F'' Yoneda10_Param_ff_ param_ff_  grade_param_ff
   | intros Yoneda00_Param_F Yoneda01_Param_F Param_F grade_param_ff
   | intros G P is_Parameter0_P Q p grade_param_ff
   | intros Yoneda00_Param_F Yoneda01_Param_F Param_F Yoneda00_Param_E Yoneda01_Param_E Param_E Yoneda10_Param_ff param_ff grade_param_ff
   | intros Yoneda00_Param_F Yoneda01_Param_F Param_F Yoneda00_Param_E Yoneda01_Param_E Param_E Yoneda10_Param_ff param_ff grade_param_ff
   | intros Yoneda00_Param_F Yoneda01_Param_F isFiniteness_Param_F Yoneda10_Param_param_ Heq_param Yoneda10_Param_param_morphism G param P is_Parameter0_P grade_param_ff
   | intros Yoneda00_Param_F Yoneda01_Param_F isFiniteness_Param_F Yoneda10_Param_param_ Heq_param Yoneda00_Param_E Yoneda01_Param_E Param_E Yoneda10_Param_ee Yoneda10_Param_ee_morphism param_ee_ grade_param_ff
   | intros Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E E Param_E  Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F F Param_F Yoneda10_Param_ff0 param_ff Yoneda10_Param_ff Yoneda10_Form_ff ff grade_param_ff ].

(** param_ff is param_ff_ o>CoMod_ param_ff' *) all: cycle 1.

(** param_ff is @'UnitCoMod_ Param_F **)
+ unshelve eexists. eexists. refine ( @'UnitCoMod_ Param_F )%sol.
  clear; abstract exact: convCoMod_Param_Refl.

(** param_ff is 'View1_ is_Parameter0_P p **)
+ unshelve eexists. eexists. refine ( 'View1_ is_Parameter0_P p )%sol.
  clear; abstract exact: convCoMod_Param_Refl.

(** param_ff is 'ViewedFunctor1_ param_ff **)
+ have [:blurbp] param_ffSol_transp :=
    (proj2_sig (solveCoMod_param len _ _ _  _ _ _  _ param_ff blurbp));
      first by clear -grade_param_ff; abstract tac_degrade grade_param_ff.
  move:   (projT1 (sval (solveCoMod_param len _ _ _  _ _ _  _ param_ff blurbp)))
          (projT2 (sval (solveCoMod_param len _ _ _  _ _ _  _ param_ff blurbp))) param_ffSol_transp
  => Yoneda10_Param_ffSol param_ffSol param_ffSol_transp .
  clear solveCoMod solveCoMod_param.

  unshelve eexists. eexists. refine ( 'ViewedFunctor1_ param_ffSol )%sol.
  move: param_ffSol_transp; clear; abstract tac_reduce.

(** param_ff is param_ff o>CoMod_ 'UnitViewedFunctor_ **)
+ have [:blurbp] param_ffSol_transp :=
    (proj2_sig (solveCoMod_param len _ _ _  _ _ _  _ param_ff blurbp));
      first by clear -grade_param_ff; abstract tac_degrade grade_param_ff.
  move:   (projT1 (sval (solveCoMod_param len _ _ _  _ _ _  _ param_ff blurbp)))
          (projT2 (sval (solveCoMod_param len _ _ _  _ _ _  _ param_ff blurbp))) param_ffSol_transp
  => Yoneda10_Param_ffSol param_ffSol param_ffSol_transp .
  clear solveCoMod solveCoMod_param.

  unshelve eexists. eexists. refine ( param_ffSol o>CoMod_ 'UnitViewedFunctor_ )%sol.
  move: param_ffSol_transp; clear; abstract tac_reduce.

(** param_ff is 'PolyElement_ param @_ isFiniteness_Param_F , is_Parameter0_P ,  Heq_param , Yoneda10_Param_param_morphism  **)
+ unshelve eexists. eexists. refine ( 'PolyElement_  param  @_ isFiniteness_Param_F , is_Parameter0_P , Heq_param , Yoneda10_Param_param_morphism )%sol.
  clear; abstract exact: convCoMod_Param_Refl.

(** param_ff is [[_ param_ee_ @_ isFiniteness_Param_F ]] **)
+ have [:blurbp_] param_eeSol_transp G param P is_Parameter0_P :=
    (proj2_sig (solveCoMod_param len _ _ _  _ _ _  _ (param_ee_(G)(param)(P)(is_Parameter0_P)) (blurbp_ G param P is_Parameter0_P)));
      first by clear -grade_param_ff;
      abstract((move => G param P is_Parameter0_P);
               destruct is_Parameter0_P;
               match goal with
               | [ isFiniteness_Param_F : Finiteness.isFiniteness_Param_ Yoneda01_Param_F  |- _ ] =>
                 destruct (Finiteness.is_viewingFunctorParamElement12_allP isFiniteness_Param_F param)
               end;
               tac_degrade grade_param_ff).
  have @Yoneda10_Param_eeSol_ := (fun G param P is_Parameter0_P =>
     projT1 (sval (solveCoMod_param len _ _ _  _ _ _  _ (param_ee_(G)(param)(P)(is_Parameter0_P)) (blurbp_ G param P is_Parameter0_P)))).
  have @param_eeSol_ : (forall G param P is_Parameter0_P ,
   'CoMod_( View_Param P ~> Param_E @_ Yoneda10_Param_eeSol_ G param P is_Parameter0_P ) %sol)
    := (fun G param P is_Parameter0_P => (projT2 (sval (solveCoMod_param len _ _ _  _ _ _  _
                                                (param_ee_(G)(param)(P)(is_Parameter0_P)) (blurbp_ G param P is_Parameter0_P))))) .
  have {param_eeSol_transp}: (forall G param P is_Parameter0_P ,
                         Sol.toPolyMor_param (param_eeSol_(G)(param)(P)(is_Parameter0_P)) <~~_ param_ee_(G)(param)(P)(is_Parameter0_P)) := param_eeSol_transp.
  move: Yoneda10_Param_eeSol_ param_eeSol_ => Yoneda10_Param_eeSol_ param_eeSol_ param_eeSol_transp.
  clear solveCoMod solveCoMod_param.

  unshelve eexists. eexists.
  refine ( [[_  param_eeSol_  @_ isFiniteness_Param_F , Heq_param , _  ]] %sol ).

  (** Yoneda10_Param_ee_morphism *)
  { clear -Yoneda10_Param_ee_morphism param_eeSol_transp.
    abstract ((move: (fun G param P is_Parameter0_P => convCoMod_sense_param (param_eeSol_transp G param P is_Parameter0_P)) => param_eeSol_transp_eq);
    intros; do 2 rewrite (param_eeSol_transp_eq _ _);
    exact: Yoneda10_Param_ee_morphism).
  }

  move: param_eeSol_transp; clear; abstract tac_reduce.

(** ff is 'Formatting ff @_ param_ff **)
+ have [:blurb] ffSol_transp :=
    (proj2_sig (solveCoMod len _ _ _ _ _ _ _ _ _ _ _ _ _ _ ff blurb));
      first by clear -grade_param_ff; abstract tac_degrade grade_param_ff.
  move: (projT1 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _  ff blurb)))
          (projT1 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _  ff blurb))))
          (projT2 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _ ff blurb)))) ffSol_transp
  => Yoneda10_Param_ffSol Yoneda10_Form_ffSol ffSol ffSol_transp .
  have [:blurbp] param_ffSol_transp :=
    (proj2_sig (solveCoMod_param len _ _ _  _ _ _  _ param_ff blurbp));
      first by clear -grade_param_ff; abstract tac_degrade grade_param_ff.
  move:   (projT1 (sval (solveCoMod_param len _ _ _  _ _ _  _ param_ff blurbp)))
          (projT2 (sval (solveCoMod_param len _ _ _  _ _ _  _ param_ff blurbp))) param_ffSol_transp
  => Yoneda10_Param_ffSol0 param_ffSol param_ffSol_transp .
  clear solveCoMod solveCoMod_param.

  unshelve eexists. eexists.
  refine ( 'Formatting ffSol @_ param_ffSol )%sol.

  move: param_ffSol_transp ffSol_transp; clear; abstract tac_reduce.

(** param_ff is param_ff_ o>CoMod_ param_ff' **)
+ have [:blurbp] param_ff'Sol_transp :=
    (proj2_sig (solveCoMod_param len _ _ _  _ _ _  _ param_ff' blurbp));
      first by clear -grade_param_ff; abstract tac_degrade grade_param_ff.
  move:   (projT1 (sval (solveCoMod_param len _ _ _  _ _ _  _ param_ff' blurbp)))
          (projT2 (sval (solveCoMod_param len _ _ _  _ _ _  _ param_ff' blurbp))) param_ff'Sol_transp
  => Yoneda10_Param_ff'Sol param_ff'Sol param_ff'Sol_transp .
have [:blurbp] param_ff_Sol_transp :=
    (proj2_sig (solveCoMod_param len _ _ _  _ _ _  _ param_ff_ blurbp));
      first by clear -grade_param_ff; abstract tac_degrade grade_param_ff.
  move:   (projT1 (sval (solveCoMod_param len _ _ _  _ _ _  _ param_ff_ blurbp)))
          (projT2 (sval (solveCoMod_param len _ _ _  _ _ _  _ param_ff_ blurbp))) param_ff_Sol_transp
  => Yoneda10_Param_ff_Sol param_ff_Sol param_ff_Sol_transp .

  (** param_ff is (param_ff_ o>CoMod_ param_ff') , to (param_ff_Sol o>CoMod_ param_ff'Sol)  **)
  destruct param_ff'Sol as
  [ Yoneda00_Param_F Yoneda01_Param_F Param_F
   | G P is_Parameter0_P Q p
   | Yoneda00_Param_F Yoneda01_Param_F Param_F Yoneda00_Param_E Yoneda01_Param_E Param_E Yoneda10_Param_ff param_ff
   | Yoneda00_Param_F Yoneda01_Param_F Param_F Yoneda00_Param_E Yoneda01_Param_E Param_E Yoneda10_Param_ff param_ff
   | Yoneda00_Param_F Yoneda01_Param_F isFiniteness_Param_F Yoneda10_Param_param_ Heq_param Yoneda10_Param_param_morphism G param P is_Parameter0_P
   | Yoneda00_Param_F Yoneda01_Param_F isFiniteness_Param_F Yoneda10_Param_param_ Heq_param Yoneda00_Param_E Yoneda01_Param_E Param_E Yoneda10_Param_ee Yoneda10_Param_ee_morphism param_ee_
   | Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E E Param_E Yoneda00_Form_F Yoneda01_Form_F Yoneda00_Param_F Yoneda01_Param_F Yoneda10_FormParam_F F Param_F  Yoneda10_Param_ff0 param_ff Yoneda10_Param_ff Yoneda10_Form_ff ff ].

  (** param_ff is (param_ff_ o>CoMod_ param_ff') , to (param_ff_Sol o>CoMod_ param_ff'Sol)  ,
is (param_ff_Sol o>CoMod_ (@'UnitCoMod_ Param_F)) **)
  * unshelve eexists. eexists. refine (param_ff_Sol)%sol.
    move: param_ff_Sol_transp param_ff'Sol_transp; clear;
      abstract (tac_simpl; intros; eapply convCoMod_Param_Trans with
                                   (uTrans := param_ff_ o>CoMod_ ('UnitCoMod_)); tac_reduce).

  (** param_ff is (param_ff_ o>CoMod_ param_ff') , to (param_ff_Sol o>CoMod_ param_ff'Sol)  ,
is (param_ff_Sol o>CoMod_ ( 'View1_ is_Parameter0_P p )) **)
  * move: (Sol.DestructParam.Destruct_codomView.morCoMod_codomViewP param_ff_Sol) => param_ff_Sol_codomViewP.
    { destruct param_ff_Sol_codomViewP as
          [ _P
          | _G _P _is_Parameter0_P _Q _p ].

      (** param_ff is (param_ff_ o>CoMod_ param_ff') , to (param_ff_Sol o>CoMod_ param_ff'Sol)  ,
is (( @'UnitCoMod_ (View_Param _P) ) o>CoMod_ ( 'View1_ is_Parameter0_P p )) **)
      - unshelve eexists. eexists. refine ( 'View1_ is_Parameter0_P p )%sol.
        move: param_ff_Sol_transp param_ff'Sol_transp; clear;
          abstract (tac_simpl; intros; eapply convCoMod_Param_Trans with
                                       (uTrans := ('UnitCoMod_) o>CoMod_ ('View1_ is_Parameter0_P p)); tac_reduce).

      (** param_ff is (param_ff_ o>CoMod_ param_ff') , to (param_ff_Sol o>CoMod_ param_ff'Sol)  ,
is (( 'View1_ _is_Parameter0_P _p ) o>CoMod_ ( 'View1_ _is_Parameter0_P p )) **)
      - unshelve eexists. eexists.
        refine ( 'View1_ _is_Parameter0_P (_p o>Parametrizator p) )%sol.
        move: param_ff_Sol_transp param_ff'Sol_transp; clear;
          abstract (tac_simpl; intros; eapply convCoMod_Param_Trans with
                                       (uTrans := ('View1_ _is_Parameter0_P _p) o>CoMod_ ('View1_ is_Parameter0_P p)); tac_reduce).
    }

  (** param_ff is (param_ff_ o>CoMod_ param_ff') , to (param_ff_Sol o>CoMod_ param_ff'Sol)  ,
is (param_ff_Sol o>CoMod_ ('ViewedFunctor1_ param_ff)) **)
  * move:  (Sol.DestructParam.Destruct_codomViewedFunctor.morCoMod_codomViewedFunctorP param_ff_Sol) => param_ff_Sol_codomViewedFunctorP.
    { destruct param_ff_Sol_codomViewedFunctorP as
          [ _Yoneda00_Param_F  _Yoneda01_Param_F _Param_F
          | _Yoneda00_Param_F  _Yoneda01_Param_F _Param_F Yoneda00_Param_E Yoneda01_Param_E Param_E  _Yoneda10_Param_ff _param_ff
          | _Yoneda00_Param_F  _Yoneda01_Param_F _Param_F  Yoneda00_Param_E Yoneda01_Param_E Param_E _Yoneda10_Param_ff  _param_ff
          | _Yoneda00_Param_F  _Yoneda01_Param_F isFiniteness_Param_F Yoneda10_Param_param_  Heq_param Yoneda00_Param_E  Yoneda01_Param_E Param_E  Yoneda10_Param_ee  Yoneda10_Param_ee_morphism param_ee_ ] .

      (** param_ff is (param_ff_ o>CoMod_ param_ff') , to (param_ff_Sol o>CoMod_ param_ff'Sol)  ,
is ((@'UnitCoMod_ _Param_F) o>CoMod_ ('ViewedFunctor1_ param_ff )) **)
       - unshelve eexists. eexists. refine ('ViewedFunctor1_ param_ff)%sol.
         move: param_ff_Sol_transp param_ff'Sol_transp; clear;
           abstract (tac_simpl; intros; eapply convCoMod_Param_Trans with
                                        (uTrans := ('UnitCoMod_) o>CoMod_ ('ViewedFunctor1_ (Sol.toPolyMor_param param_ff))); tac_reduce).

       (** param_ff is (param_ff_ o>CoMod_ param_ff') , to (param_ff_Sol o>CoMod_ param_ff'Sol)  ,
is (('ViewedFunctor1_  _param_ff) o>CoMod_ ('ViewedFunctor1_ param_ff )) **)
       - have [:blurbp] _param_ff_o_param_ff_transp :=
          (proj2_sig (solveCoMod_param len _ _ _  _ _ _  _ (Sol.toPolyMor_param _param_ff o>CoMod_ Sol.toPolyMor_param param_ff) blurbp));
            first by clear -grade_param_ff param_ff_Sol_transp param_ff'Sol_transp; abstract tac_degrade grade_param_ff.
        move:   (projT1 (sval (solveCoMod_param len _ _ _  _ _ _  _ (Sol.toPolyMor_param _param_ff o>CoMod_ Sol.toPolyMor_param param_ff) blurbp)))
                  (projT2 (sval (solveCoMod_param len _ _ _  _ _ _  _ (Sol.toPolyMor_param _param_ff o>CoMod_ Sol.toPolyMor_param param_ff) blurbp))) _param_ff_o_param_ff_transp
        => Yoneda10_Param__param_ff_o_param_ff _param_ff_o_param_ff _param_ff_o_param_ff_transp .
        clear solveCoMod solveCoMod_param.

        unshelve eexists. eexists.
        refine ( 'ViewedFunctor1_ _param_ff_o_param_ff )%sol.

        move: param_ff_Sol_transp param_ff'Sol_transp _param_ff_o_param_ff_transp; clear;
          abstract (tac_simpl; intros; eapply convCoMod_Param_Trans with
                 (uTrans := ( 'ViewedFunctor1_ (Sol.toPolyMor_param _param_ff) )
                              o>CoMod_ ( 'ViewedFunctor1_ (Sol.toPolyMor_param param_ff) )); tac_reduce).

       (** param_ff is (param_ff_ o>CoMod_ param_ff') , to (param_ff_Sol o>CoMod_ param_ff'Sol)  ,
is ((_param_ff o>CoMod_ 'UnitViewedFunctor_) o>CoMod_ ('ViewedFunctor1_ param_ff )) **)
       - have [:blurbp] _param_ff_o_param_ff_transp :=
          (proj2_sig (solveCoMod_param len _ _ _  _ _ _  _ (Sol.toPolyMor_param _param_ff o>CoMod_ Sol.toPolyMor_param param_ff) blurbp));
            first by clear -grade_param_ff param_ff_Sol_transp param_ff'Sol_transp; abstract tac_degrade grade_param_ff.
        move:   (projT1 (sval (solveCoMod_param len _ _ _  _ _ _  _ (Sol.toPolyMor_param _param_ff o>CoMod_ Sol.toPolyMor_param param_ff) blurbp)))
                  (projT2 (sval (solveCoMod_param len _ _ _  _ _ _  _ (Sol.toPolyMor_param _param_ff o>CoMod_ Sol.toPolyMor_param param_ff) blurbp))) _param_ff_o_param_ff_transp
        => Yoneda10_Param__param_ff_o_param_ff _param_ff_o_param_ff _param_ff_o_param_ff_transp .
        clear solveCoMod solveCoMod_param.

        unshelve eexists. eexists.
        refine ( _param_ff_o_param_ff o>CoMod_ 'UnitViewedFunctor_ )%sol.

        move: param_ff_Sol_transp param_ff'Sol_transp _param_ff_o_param_ff_transp; clear;
          abstract (tac_simpl; intros; eapply convCoMod_Param_Trans with
                 (uTrans := ( (Sol.toPolyMor_param _param_ff) o>CoMod_ 'UnitViewedFunctor_ )
                              o>CoMod_ ( 'ViewedFunctor1_ (Sol.toPolyMor_param param_ff) )); tac_reduce).

       (** param_ff is (param_ff_ o>CoMod_ param_ff') , to (param_ff_Sol o>CoMod_ param_ff'Sol)  ,
is ( [[_ param_ee_ @_ isFiniteness_Param_F , Heq_param , Yoneda10_Param_ee_morphism ]] o>CoMod_ ('ViewedFunctor1_ param_ff )) **)
       - have [:blurbp_] param_ee_o_param_ff_transp G param P is_Parameter0_P :=
           (proj2_sig (solveCoMod_param len _ _ _  _ _ _  _
            ((Sol.toPolyMor_param (param_ee_(G)(param)(P)(is_Parameter0_P))) o>CoMod_ Sol.toPolyMor_param param_ff) (blurbp_ G param P is_Parameter0_P)));
             first by clear -grade_param_ff param_ff_Sol_transp param_ff'Sol_transp;
             abstract((move => G param P is_Parameter0_P);
                      destruct is_Parameter0_P;
                      match goal with
                      | [ isFiniteness_Param_F : Finiteness.isFiniteness_Param_ _Yoneda01_Param_F |- _ ] =>
                        destruct (Finiteness.is_viewingFunctorParamElement12_allP isFiniteness_Param_F param)
                      end; tac_degrade grade_param_ff).
         have @Yoneda10_param_ee_o_param_ff_ :=
           (fun G param P is_Parameter0_P => projT1 (sval (solveCoMod_param len _ _ _  _ _ _  _
             ((Sol.toPolyMor_param (param_ee_(G)(param)(P)(is_Parameter0_P))) o>CoMod_ Sol.toPolyMor_param param_ff) (blurbp_ G param P is_Parameter0_P)))).
         have @param_ee_o_param_ff_ :
           (forall G param P is_Parameter0_P, 'CoMod_( View_Param P ~> Param_F @_ Yoneda10_param_ee_o_param_ff_ G param P is_Parameter0_P ) %sol)
           := (fun G param P is_Parameter0_P => (projT2 (sval (solveCoMod_param len _ _ _  _ _ _  _
             ((Sol.toPolyMor_param (param_ee_(G)(param)(P)(is_Parameter0_P))) o>CoMod_ Sol.toPolyMor_param param_ff) (blurbp_ G param P is_Parameter0_P))))) .
         have {param_ee_o_param_ff_transp}:
           (forall G param P is_Parameter0_P, Sol.toPolyMor_param (param_ee_o_param_ff_(G)(param)(P)(is_Parameter0_P)) <~~_ (Sol.toPolyMor_param (param_ee_(G)(param)(P)(is_Parameter0_P))) o>CoMod_ Sol.toPolyMor_param param_ff) := param_ee_o_param_ff_transp.
         move: Yoneda10_param_ee_o_param_ff_ param_ee_o_param_ff_ =>
         Yoneda10_param_ee_o_param_ff_ param_ee_o_param_ff_ param_ee_o_param_ff_transp.
         clear solveCoMod solveCoMod_param.

         unshelve eexists. eexists.
         refine ( [[_  param_ee_o_param_ff_  @_ isFiniteness_Param_F ,  Heq_param , _ ]] %sol ).

         (** Yoneda10_Param_ee_morphism *)
         { clear -Yoneda10_Param_ee_morphism param_ee_o_param_ff_transp;
           abstract ((move: (fun G param P is_Parameter0_P => convCoMod_sense_param (param_ee_o_param_ff_transp G param P is_Parameter0_P))
                      => param_ee_o_param_ff_transp_eq);
                     intros; do 2 rewrite (param_ee_o_param_ff_transp_eq _ _) /=;
                     congr (sval Yoneda10_Param_ff _); exact: Yoneda10_Param_ee_morphism).
         }

         move: param_ff_Sol_transp param_ff'Sol_transp param_ee_o_param_ff_transp; clear;
           abstract (tac_simpl; intros; eapply convCoMod_Param_Trans with
                 (uTrans := ( [[_ (fun G param P is_Parameter0_P => (Sol.toPolyMor_param (param_ee_(G)(param)(P)(is_Parameter0_P))))
                                 @_ isFiniteness_Param_F , Heq_param , Yoneda10_Param_ee_morphism ]] )
                              o>CoMod_ ( 'ViewedFunctor1_ (Sol.toPolyMor_param param_ff) )); tac_reduce).
    }

  (** param_ff is (param_ff_ o>CoMod_ param_ff') , to (param_ff_Sol o>CoMod_ param_ff'Sol)  ,
is (param_ff_Sol o>CoMod_ (param_ff o>CoMod_ 'UnitViewedFunctor_ )) **)
  * have [:blurbp] param_ff_Sol_o_param_ff_transp :=
      (proj2_sig (solveCoMod_param len _ _ _  _ _ _  _ (Sol.toPolyMor_param param_ff_Sol o>CoMod_ Sol.toPolyMor_param param_ff) blurbp));
        first by clear -grade_param_ff param_ff_Sol_transp param_ff'Sol_transp; abstract tac_degrade grade_param_ff.
    move:   (projT1 (sval (solveCoMod_param len _ _ _  _ _ _  _ (Sol.toPolyMor_param param_ff_Sol o>CoMod_ Sol.toPolyMor_param param_ff) blurbp)))
              (projT2 (sval (solveCoMod_param len _ _ _  _ _ _  _ (Sol.toPolyMor_param param_ff_Sol o>CoMod_ Sol.toPolyMor_param param_ff) blurbp))) param_ff_Sol_o_param_ff_transp
    => Yoneda10_Param_param_ff_Sol_o_param_ff param_ff_Sol_o_param_ff param_ff_Sol_o_param_ff_transp .
    clear solveCoMod solveCoMod_param.

    unshelve eexists. eexists.
    refine ( param_ff_Sol_o_param_ff o>CoMod_ 'UnitViewedFunctor_ )%sol.
    move: param_ff_Sol_transp param_ff'Sol_transp param_ff_Sol_o_param_ff_transp; clear;
    abstract (tac_simpl; intros; eapply convCoMod_Param_Trans with
                  (uTrans := ( Sol.toPolyMor_param param_ff_Sol )
                     o>CoMod_ ( (Sol.toPolyMor_param param_ff) o>CoMod_ 'UnitViewedFunctor_ )); tac_reduce).

  (** param_ff is (param_ff_ o>CoMod_ param_ff') , to (param_ff_Sol o>CoMod_ param_ff'Sol)  ,
is (param_ff_Sol o>CoMod_ ('PolyElement_ param @_ isFiniteness_Param_F , is_Parameter0_P , Heq_param, Yoneda10_Param_param_morphism)) **)
  * move: (Sol.DestructParam.Destruct_codomView.morCoMod_codomViewP param_ff_Sol) => param_ff_Sol_codomViewP.
    { destruct param_ff_Sol_codomViewP as
          [ P
          | _G P _is_Parameter0_P Q p ].
      (**MEMO: OLD ERROR /!\ HOHOHO CLANDESTNE /!\ **)

      (** param_ff is (param_ff_ o>CoMod_ param_ff') , to (param_ff_Sol o>CoMod_ param_ff'Sol)  ,
is (( @'UnitCoMod_ (View_Param P) ) o>CoMod_ ('PolyElement_ param @_ isFiniteness_Param_F , is_Parameter0_P , Heq_param, Yoneda10_Param_param_morphism)) **)
       - unshelve eexists. eexists. refine ('PolyElement_ param @_ isFiniteness_Param_F , is_Parameter0_P , Heq_param, Yoneda10_Param_param_morphism)%sol.
         move: param_ff_Sol_transp param_ff'Sol_transp; clear;
           abstract (tac_simpl; intros; eapply convCoMod_Param_Trans with
                                        (uTrans := ('UnitCoMod_) o>CoMod_ ('PolyElement_ param @_ isFiniteness_Param_F , is_Parameter0_P , Heq_param, Yoneda10_Param_param_morphism)); tac_reduce).

       (** param_ff is (param_ff_ o>CoMod_ param_ff') , to (param_ff_Sol o>CoMod_ param_ff'Sol)  ,
is (( 'View1_ _is_Parameter0_P p ) o>CoMod_ ('PolyElement_ param @_ isFiniteness_Param_F , Heq_param , Yoneda10_Param_param_morphism @^ F)) **)
       - unshelve eexists. eexists. refine ( 'PolyElement_ ( sval (Yoneda10_Param_param_ G param _ is_Parameter0_P) _G (is_Parameter0_transp_dom _is_Parameter0_P p) )
                     @_ isFiniteness_Param_F , _is_Parameter0_P , Heq_param , Yoneda10_Param_param_morphism )%sol.
         move: param_ff_Sol_transp param_ff'Sol_transp; clear;
           abstract (tac_simpl; intros; eapply convCoMod_Param_Trans with
                                        (uTrans := ( 'View1_ _is_Parameter0_P p ) o>CoMod_ ('PolyElement_ param @_ isFiniteness_Param_F , is_Parameter0_P , Heq_param, Yoneda10_Param_param_morphism)); tac_reduce).
    }

  (** param_ff is (param_ff_ o>CoMod_ param_ff') , to (param_ff_Sol o>CoMod_ param_ff'Sol)  ,
is (param_ff_Sol o>CoMod_ ( [[_  param_ee_ @_ isFiniteness_Param_F ,  Heq_param , Yoneda10_Param_ee_morphism ]] )) **)
  * move:  (Sol.DestructParam.Destruct_codomViewingFunctor.morCoMod_codomViewingFunctorP param_ff_Sol) => param_ff_Sol_codomViewingFunctorP.
    { destruct param_ff_Sol_codomViewingFunctorP as
          [ Yoneda00_Param_F Yoneda01_Param_F isFiniteness_Param_F
          | Yoneda00_Param_F Yoneda01_Param_F isFiniteness_Param_F  x_Yoneda10_Param_param_ _Heq_param Yoneda10_Param_param_morphism G  param  P  is_Parameter0_P ] .

      (** param_ff is (param_ff_ o>CoMod_ param_ff') , to (param_ff_Sol o>CoMod_ param_ff'Sol)  ,
is (('UnitCoMod_) o>CoMod_ ( [[_  param_ee_ @_ isFiniteness_Param_F ,  Heq_param , Yoneda10_Param_ee_morphism ]] )) **)
      - unshelve eexists. eexists. refine ( [[_  param_ee_ @_ isFiniteness_Param_F ,  Heq_param , Yoneda10_Param_ee_morphism ]] )%sol.
        move: param_ff_Sol_transp param_ff'Sol_transp; clear;
          abstract (tac_simpl; intros; eapply convCoMod_Param_Trans with
                (uTrans := ('UnitCoMod_) o>CoMod_ ( [[_ (fun G param P is_Parameter0_P => Sol.toPolyMor_param (param_ee_(G)(param)(P)(is_Parameter0_P))) @_ isFiniteness_Param_F , Heq_param , Yoneda10_Param_ee_morphism ]] )); tac_reduce).

        (** param_ff is (param_ff_ o>CoMod_ param_ff') , to (param_ff_Sol o>CoMod_ param_ff'Sol)  ,
is (('PolyElement_ param @_ isFiniteness_Param_F , is_Parameter0_P , _Heq_param , Yoneda10_Param_param_morphism) o>CoMod_ ( [[_  param_ee_ @_ isFiniteness_Param_F ,  Heq_param , Yoneda10_Param_ee_morphism ]] )) **)
      - unshelve eexists. eexists.
        refine ( (param_ee_(G)(param)(P)(is_Parameter0_P)) o>CoMod_ 'UnitViewedFunctor_ )%sol.
        move: param_ff_Sol_transp param_ff'Sol_transp; clear;
          abstract (tac_simpl; intros; eapply convCoMod_Param_Trans with
                (uTrans := ( 'PolyElement_ param @_ isFiniteness_Param_F , is_Parameter0_P , _Heq_param , Yoneda10_Param_param_morphism ) o>CoMod_ ( [[_ (fun G param P is_Parameter0_P => Sol.toPolyMor_param (param_ee_(G)(param)(P)(is_Parameter0_P))) @_ isFiniteness_Param_F , _Heq_param , Yoneda10_Param_ee_morphism  ]] )); tac_reduce).
    }

  (** param_ff is (param_ff_ o>CoMod_ param_ff') , to (param_ff_Sol o>CoMod_ param_ff'Sol)  ,
is (param_ff_Sol o>CoMod_ ( 'Formatting ff @_ param_ff )) **)
  * move: (Sol.DestructParam.Destruct_codomFormat.morCoMod_codomFormatP param_ff_Sol) => param_ff_Sol_codomFormatP.
    { destruct param_ff_Sol_codomFormatP as
          [ _Yoneda00_Form_F _Yoneda01_Form_F _Yoneda00_Param_F _Yoneda01_Param_F _Yoneda10_FormParam_F
            _F _Param_F
          | Yoneda00_Form_E Yoneda01_Form_E Yoneda00_Param_E Yoneda01_Param_E Yoneda10_FormParam_E E Param_E _Yoneda00_Form_F _Yoneda01_Form_F _Yoneda00_Param_F _Yoneda01_Param_F _Yoneda10_FormParam_F _F _Param_F  _Yoneda10_Param_ff0 _param_ff  _Yoneda10_Param_ff _Yoneda10_Form_ff _ff ] .

      (** param_ff is (param_ff_ o>CoMod_ param_ff') , to (param_ff_Sol o>CoMod_ param_ff'Sol)  ,
is ((@'UnitCoMod_ (Format F Param_F)) o>CoMod_ ( 'Formatting ff @_ param_ff )) **)
      - unshelve eexists. eexists. refine ( 'Formatting ff @_ param_ff )%sol.
         move: param_ff_Sol_transp param_ff'Sol_transp; clear;
           abstract (tac_simpl; intros; eapply convCoMod_Param_Trans with
                                            (uTrans := ('UnitCoMod_) o>CoMod_ ( 'Formatting (Sol.toPolyMor ff) @_ (Sol.toPolyMor_param param_ff) )); tac_reduce).

      (** param_ff is (param_ff_ o>CoMod_ param_ff') , to (param_ff_Sol o>CoMod_ param_ff'Sol)  ,
is (( 'Formatting _ff @_ _param_ff ) o>CoMod_ ( 'Formatting ff @_ param_ff )) **)
      - have [:blurb] _ff_o_ff_transp :=
          (proj2_sig (solveCoMod len _ _ _ _ _ _ _ _ _ _ _ _ _ _ (Sol.toPolyMor _ff o>CoMod Sol.toPolyMor ff) blurb));
            first by clear -grade_param_ff param_ff_Sol_transp param_ff'Sol_transp; abstract tac_degrade grade_param_ff.
        move: (projT1 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _  (Sol.toPolyMor _ff o>CoMod Sol.toPolyMor ff) blurb)))
                (projT1 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _  (Sol.toPolyMor _ff o>CoMod Sol.toPolyMor ff) blurb))))
                (projT2 (projT2 (sval (solveCoMod len  _ _ _ _ _ _ _ _ _ _ _ _ _ _ (Sol.toPolyMor _ff o>CoMod Sol.toPolyMor ff) blurb)))) _ff_o_ff_transp
        => Yoneda10_Param__ff_o_ff Yoneda10_Form__ff_o_ff _ff_o_ff _ff_o_ff_transp .

        have [:blurbp] _param_ff_o_param_ff_transp :=
          (proj2_sig (solveCoMod_param len _ _ _  _ _ _  _ (Sol.toPolyMor_param _param_ff o>CoMod_ Sol.toPolyMor_param param_ff) blurbp));
            first by clear -grade_param_ff param_ff_Sol_transp param_ff'Sol_transp; abstract tac_degrade grade_param_ff.
        move:   (projT1 (sval (solveCoMod_param len _ _ _  _ _ _  _ (Sol.toPolyMor_param _param_ff o>CoMod_ Sol.toPolyMor_param param_ff) blurbp)))
                  (projT2 (sval (solveCoMod_param len _ _ _  _ _ _  _ (Sol.toPolyMor_param _param_ff o>CoMod_ Sol.toPolyMor_param param_ff) blurbp))) _param_ff_o_param_ff_transp
        => Yoneda10_Param__ff_o_ff0 _param_ff_o_param_ff _param_ff_o_param_ff_transp .
        clear solveCoMod solveCoMod_param.

        unshelve eexists. eexists.
        refine ( 'Formatting _ff_o_ff @_ _param_ff_o_param_ff )%sol.

        move: param_ff_Sol_transp param_ff'Sol_transp _param_ff_o_param_ff_transp _ff_o_ff_transp; clear;
          abstract (tac_simpl; intros; eapply convCoMod_Param_Trans with
                 (uTrans := ( 'Formatting (Sol.toPolyMor _ff) @_ (Sol.toPolyMor_param _param_ff) )
                              o>CoMod_ ( 'Formatting (Sol.toPolyMor ff) @_ (Sol.toPolyMor_param param_ff) )); tac_reduce).
    }
}
Defined.
End Resolve.
End PARAMETRIZATION.
(** # #
#+END_SRC

Voila.
# # **)