**********************************************************************************
****** Brouillon de la routine d'extraction/preparation de la grande CtAB' *******
****************************(cas d'etude en // aux calculs par IC)****************


       [A].[A-1]    -> f -> IC -> [ABt_TV]t     0 (hors T-probes)
    I                    --    ----    ------   .  -----
      I                  ||    |  |    |    |   .  |   |
        I                ||    |  |    |    |   .  |   |
          I              ||    |  |    |    |   .  |   |
            I            ||    |  |    |    |   .  |   |
              I          ||    |  |    |    |   .  |   |
                I        ||    |  |    |    |   .  |   |
                  I      --    ----    ------   .  -----  =>U(IC restreintes a UTV)
 .
 v   SV
 f  -xx------------
 .  |xx-----------|              lift Ct_UIC et ABt';
 v     SV'
    --xxxxx--------              Under CL(LCL)
IC  | xxxxx       |              <  loop f/IC
    |-xxxxx-------|                 < grasp Ct_SV et rangement Ct_UIC;
 .                                    Under SV
 v        SV"                         < loop Cx/TV
    -----x-xx------                     < grasp ABt_TV et rangement ABt';
Ct_TV    x xx     |                     >
    |    x xx     |                   >
    |----x-xx-----|                 >
                                  >;
    ----x----------
    |---x---------|               Information dim et banks :
                                  --------------------------
    -----x---------                dim commune : USV = dim edge de A    manque
    |    x        |                    Ct_UIC  : dim (UIC) ->(CL).Nb_Cx_Tr_Var
    |----x--------|                    ABt'    : dim (UTV)              manque

      <-USV->


            ce que l'on a :        (IC).Nb_Tr_Var (IC).Nb_Cx_St_Var
                                   (SV).Nb_St_Var
                                   (IC).LTr_in_Fc
                                   (CX).LFi_in_IF (CX).Nb_Var
                                                  (IC).Cg_SV_Nb
                                                  (IC).Nb_Tr'       new
                                                  (IC).Tr_List(#)   new

 Remarque : pour contrer l'effet peigne_TR, il faut ne conserver que UTV dans la ABt'
=====================================================================================
========= Programmation symbolique : cas des grandes matrices =======================
=====================================================================================
               Under CL(LCL)
               < ! first loop to grab parts of ABt' = restreinte a ses composantes de edge
                 ! info : dim USV, liste ordonnee des composantes
                 ! de meme, les UTV (hors T-Probes) dans l'ordre des IC - partition avec repetition des Phi_Tr
                 loop f/IC
                 < get SV(IC); loop CX/TV
                               < ABt'_TV(i,j) = . + ABt_TV(k,l)
                                 ou' j = [f]_0 + [IC]_0 + UTV_list(l), ou l= Phi #
                                     i = USV_list(k) k = Eta #
! ca veut dire que IC fournirait UTV_list(#), la CL USV_list(#)

! on peut dans la meme boucle recuperer les bouts de la Ct'
                                 Ct'(i,j) = . + Ct_TV(k,l)
                                     i = [f]_0 + [IC]_0 + k, ou k= Phi #
                                     j = USV_list(l) l = Eta #
                               >
                 >
!  produit Ct'AB' range sous la CL
                 lift Ct'AB'((CL).Nc_Cx_Tr_Var,U(IC<=UTV)
!  Ventilation :
                 il faut concatener les IC des memes Tr, et garder l'info IC_list(Tr) Tr_list(UTV) !

=====================================================================================
========= Programmation symbolique : cas des bouts et calcul par IC =================
=====================================================================================
                sous chaque IC, on extrairait ABt_SV_IC'(cad dans la UTV_list)
                une boucle sur SV pour Ct_SV*ABt_SV_IC' donne CTAB_IC_IC' : non, il reste les Ct_IC1*ABt_SV2_IC'i
           => dans tous les cas, il faut construire la grande ABt'[USV,U(IC=UTV)]
              par contre, on peut sous chaque IC calculer le produit [UCt_SV]*ABt' => Bligne [ICi,UIC']
              et ventiler dans la CtAB'

**************************************************************************************
differences d'info / avant :
      ABt_TV = dim Eta *  dim U[f/IC/Cx/Fi]]

      Ct_SV  = dim Phi *  dim C-PLug