• A
  • A
  • A
  • ABC
  • ABC
  • ABC
  • А
  • А
  • А
  • А
  • А
Regular version of the site
Language Proficiency
English
Japanese
Contacts
E-mail:
Timetable
Download CV
SPIN-RSCI: 9392-4269
ORCID: 0000-0002-1494-8295
ResearcherID: K-5517-2015
Scopus AuthorID: 23392413500
Google Scholar
Working hours
11:00 - 23:00
Supervisors
J.-F. Thisse
S. Kichko
Printable version

 

Have you spotted a typo?
Highlight it, click Ctrl+Enter and send us a message. Thank you for your help!

Sergey G. Kokovin

  • Sergey G. Kokovin has been at HSE since 2010.

Education, Degrees and Academic Titles

  • 1998
    Associate Professor
  • 1996

    Candidate of Sciences* (PhD) in Mathematical and Instrumental Methods in Economics
    Central Institute of Economics and Mathematics of the Academy of Sciences of the USSR
    Thesis Title: Equilibria with market frictions and rationing

  • 1981

    Diploma
    Lenin Komsomol Novosibirsk State University

  • 1981

    Diploma
    Lenin Komsomol Novosibirsk State University

* Candidate of Sciences
According to the International Standard Classification of Education (ISCED) 2011, Candidate of Sciences belongs to ISCED level 8 - "doctoral or equivalent", together with PhD, DPhil, D.Lit, D.Sc, LL.D, Doctorate or similar. Candidate of Sciences allows its holders to reach the level of the Associate Professor.

Student Term / Thesis Papers

Full list of of student term / thesis papers

Courses (2017/2018)

Courses (2016/2017)

Courses (2015/2016)

Courses (2014/2015)

Analysis of Imperfect Markets (Bachelor’s programme; St.Petersburg School of Economics and Management; programme "Economics"; 3 year, 3 module)Eng

Courses (2012/2013)

Analysis of Imperfect Markets (Bachelor’s programme; Faculty of Economics ; 3 year, 2, 3 module)Rus

Publications29

Figure 5: Regression for wages response to liberalization: random or fixed effects.

Employment history

1974 programmer - Institute of Mechanics SB RAS

1974-76 soldier - Soviet Army,  

1976-81 student - Novosibirsk State University

1981-2015 researcher - Institute of Mathematics

1987- .. associate professor - Novosibirsk State University

2011- .. senior researcher - Higher School of Economics, St.Petersburg

Other

(2008-2009) EERC  Research Grant 08-0361 "Generalized Monopolistic-Competition Model and Contr-competitive Paradoxes"

Other

Conference of the European Association for Research in Industrial Economics (2005),

Far Eastern Meeting for Econometric Society (2007),

Conference of the European Association for Research in Industrial Economics (2008),

23-th Annual Congress of European Economic Association and 63-th European Meeting of the Econometric Society (2008),

Far East and South Asia Meeting of the Econometric Society (2009),

Econometric Society World Congress (2010),

26-th Annual Congress of European Economic Association and 65-th European Meeting of the Econometric Society (2011),

 Far Eastern Meeting for Econometric Society (2011).

Algorithm For Screening Optimization (Wolfram-Mathematika-6, March2016)

 Файл (NB, 238 Кб)

- - - text of this screening-optimization-program: - - - 

(* Wolfram-Mathematica-6 program (version with given rivers-list March-2016) for screening-
    optimization with quadratic valuations*)
(*  *)

(* Hint for Mathematika-5.2: First open BeginPackage["Temporary`"];  <<
    DiscreteMath`Combinatorica`; then, in next Run of Proga, remove both.., 
  then you work always in one block with Context "Temporary`" *)

ClearAll[Partns,Layers,LayMat,AdjMat,i,j,k,n,AllAdMatrs,Nskipped,\
lenAllPreodTrrivs,Usedgraphs,BadTrees,niterRand,nAllRandskipped];


BeginPackage["Temporary`"];
<<Combinatorica`;

(* This program (version with given rivers-list March2016) for screening-
    optimization with quadratic valuations --  finds a solution -- quantities \
X1,X2,X3 and tariffs under any valuations, 
  searching among various possible graphs of constraints. (It is written in \
the form allowing to expand program to case of 4 or more agent types, 
          but expansion is not accomplished, 
          somewhere dimensionality 3 remains fixed in progr instead of \
flexible n.)
      It first performs Layers-method for building all graph-
    rivers from all trees and enumerates them. Column #1 in adjacency-
    matrix is the root (agent-node 0 in theory), 
  nodes #2, #3, #4 (nodes 1, 2, 3 in theory) are agents.
      Construction of graphs works like this: 
      From labelled nodes {1,2,...,n} out of a would-be digraph, 
  connecting the nodes, we build all possible trees one-by-one, 
  classifying them into Families, 
  according to longest-path-
    layers (see paper ScreeningStructures.tex). After building a tree, 
  we enrich each tree with various bypasses to get Relatives of this tree, 
  i.e., to build its river-
    family. But afterwards we should exclude intersections generated. Namely, 
  from each tree, we try ALL bypasses downstream,
  throwing away rivers with the same unique INDEX as existed previously! 
      Preorder-vector makes INDEX, it is a vector characterizing a river, 
  generated from the arcs-
      vector like {{1,0},{2,1},{3,1},{3,2},{4,2}}. INDEX can look like ={1,1,
        1,1} or {1,2,2,1} or bigger. 
        Each ``attempt''("try") to build a river, 
  adds +1 to the lowest layer of index. 
        When a layer in index becomes ``full'' we make it empty and the next \
layer gets +1. INDEX looks like decimal numbers, 
  but is n-imal instead of decimal, and rightmost=biggest.
            
            I have an Example with almost-
        equal profit on different trees: A={4,5,6};
  B={1.2,2,2.1}; dd={0,0,0};Mm={1,1,2};
  
  A={1.0,0.8,1.2};
  B={1.2,1.0,1.7};
  dd={0,0,0};
  Mm={1,1,2}; - example when funkc  profit concave?  
  *)

ClearAll[a,b,c,f,niterRand];
Print["Start preparing data:"];

ClearAll[Partns,Layers,LayMat,AdjMat,i,j,k,n,AllAdMatrs,Nskipped,
    lenAllPreodTrrivs,Usedgraphs];
Pechat=False;
Pech=False (*  False True  printing main details of calculations *); 
Pech11=False (* False True - shows  AdjMatrix*);
Pech22=False (* False True  -shows adding elements of AdjMatrix*) 
Pech33=False (* False True  -shows other details *)(* 
     three regimes of Printing certain intermediate results of optimization 
List of Rivers explored:  *);
RiversList={{{2,1},{3,1},{4,1}},{{2,1},{3,2},{4,2}},{{2,1},{3,1},{3,2},{4,
          2}},{{2,1},{3,2},{4,1},{4,2}},{{2,1},{3,1},{3,2},{4,1},{4,2}},{{3,
          1},{4,1},{2,3}},{{3,1},{4,1},{2,4}},{{3,1},{4,1},{2,1},{2,3}},{{3,
          1},{4,1},{2,1},{2,4}},{{3,1},{4,1},{2,3},{2,4}},{{3,1},{4,1},{2,
          1},{2,3},{2,4}},{{2,1},{3,1},{4,2}},{{2,1},{3,1},{4,3}},{{2,1},{3,
          1},{4,1},{4,2}},{{2,1},{3,1},{4,1},{4,3}},{{2,1},{3,1},{4,2},{4,
          3}},{{2,1},{3,1},{4,1},{4,2},{4,3}},{{4,1},{2,4},{3,4}},{{4,1},{2,
          1},{2,4},{3,4}},{{4,1},{2,4},{3,1},{3,4}},{{4,1},{2,1},{2,4},{3,
          1},{3,4}},{{2,1},{4,1},{3,2}},{{2,1},{4,1},{3,4}},{{2,1},{4,1},{3,
          1},{3,2}},{{2,1},{4,1},{3,1},{3,4}},{{2,1},{4,1},{3,2},{3,4}},{{2,
          1},{4,1},{3,1},{3,2},{3,4}},{{3,1},{2,3},{4,3}},{{3,1},{2,1},{2,
          3},{4,3}},{{3,1},{2,3},{4,1},{4,3}},{{3,1},{2,1},{2,3},{4,1},{4,
          3}},{{2,1},{3,2},{4,3}},{{2,1},{3,1},{3,2},{4,3}},{{2,1},{3,2},{4,
          1},{4,3}},{{2,1},{3,1},{3,2},{4,1},{4,3}},{{2,1},{3,2},{4,2},{4,
          3}},{{2,1},{3,1},{3,2},{4,2},{4,3}},{{2,1},{3,2},{4,1},{4,2},{4,
          3}},{{2,1},{3,1},{3,2},{4,1},{4,2},{4,3}},{{2,1},{4,2},{3,4}},{{2,
          1},{4,1},{4,2},{3,4}},{{2,1},{4,2},{3,1},{3,4}},{{2,1},{4,1},{4,
          2},{3,1},{3,4}},{{2,1},{4,2},{3,2},{3,4}},{{2,1},{4,1},{4,2},{3,
          2},{3,4}},{{2,1},{4,2},{3,1},{3,2},{3,4}},{{2,1},{4,1},{4,2},{3,
          1},{3,2},{3,4}},{{3,1},{2,3},{4,2}},{{3,1},{2,1},{2,3},{4,2}},{{3,
          1},{2,3},{4,1},{4,2}},{{3,1},{2,1},{2,3},{4,1},{4,2}},{{3,1},{2,
          3},{4,3},{4,2}},{{3,1},{2,1},{2,3},{4,3},{4,2}},{{3,1},{2,3},{4,
          1},{4,3},{4,2}},{{3,1},{2,1},{2,3},{4,1},{4,3},{4,2}},{{3,1},{4,
          3},{2,4}},{{3,1},{4,1},{4,3},{2,4}},{{3,1},{4,3},{2,1},{2,4}},{{3,
          1},{4,1},{4,3},{2,1},{2,4}},{{3,1},{4,3},{2,3},{2,4}},{{3,1},{4,
          1},{4,3},{2,3},{2,4}},{{3,1},{4,3},{2,1},{2,3},{2,4}},{{3,1},{4,
          1},{4,3},{2,1},{2,3},{2,4}},{{4,1},{2,4},{3,2}},{{4,1},{2,1},{2,
          4},{3,2}},{{4,1},{2,4},{3,1},{3,2}},{{4,1},{2,1},{2,4},{3,1},{3,
          2}},{{4,1},{2,4},{3,4},{3,2}},{{4,1},{2,1},{2,4},{3,4},{3,2}},{{4,
          1},{2,4},{3,1},{3,4},{3,2}},{{4,1},{2,1},{2,4},{3,1},{3,4},{3,
          2}},{{4,1},{3,4},{2,3}},{{4,1},{3,1},{3,4},{2,3}},{{4,1},{3,4},{2,
          1},{2,3}},{{4,1},{3,1},{3,4},{2,1},{2,3}},{{4,1},{3,4},{2,4},{2,
          3}},{{4,1},{3,1},{3,4},{2,4},{2,3}},{{4,1},{3,4},{2,1},{2,4},{2,
          3}},{{4,1},{3,1},{3,4},{2,1},{2,4},{2,3}}};
lenRivList=Length[RiversList];

(*Proga for solving Tree-optimization through differentiating function Pi *)

n=3; (* 3 agents-types (I have not expanded progr for 4!),
  data for quadratic valuations like d+ax-bx^2/2  are
      defined and modified by the following coefficients: *) 

niterRa=800;
nAllRandskipped=0;
ntimesstartoptAll=0;


For[itrand=1,itrand\[LessEqual]niterRa,itrand++,
    (
      ClearAll[A,B,dd,Vo,Votx,Vi,Vv,Mm,Xcurr,niterRand,
        x1,x2,x3,t1,t2,t3,VmatrotX,TT,findmax1];
      Print[itrand,"=itrand ********"];
      
      A=A={1.0,0.8,1.2}; (* coeff-linear of  V  *)
      B={1.6,2.4,1.4}; (* coeff-quadratic of  V  *)
      dd={0,0,0}; (* zero value of  V at zero *)
      Mm={5,0.5,2  (* ,4 ,5 *)};  
      
      Mm[[1]]=0.1+Random[]+0.1;
      Mm[[2]]=0.1+Random[]+0.1;
      Mm[[3]]=0.1+Random[]+0.1;
      A[[1]]=0.1+Random[]+0.1;
      A[[2]]=0.1+Random[]+0.1;
      A[[3]]=0.1+Random[]+0.1;
      B[[1]]=0.1+Random[]+0.1;
      B[[2]]=0.1+Random[]+0.1;
      B[[3]]=0.1+Random[]+0.1;
      
      Uopt=-100; (*starting value of lower bound for naive solution *)
      rho=-0.00001; (*relaxation parameter *)
      ntimesstartopt=0;
      (* Vector Vi of functions (#1 means "argument 1") -  
          3 quadratic valuations for 3 agents is
            defined as: *)
      Vi=Function[{dd[[1]]+A[[1]] #1[[1]]-B[[1]]#1[[1]]^2, 
            dd[[2]]+A[[2]] #1[[2]]-B[[2]]#1[[2]]^2,
            
            dd[[3]]+A[[3]] #1[[3]]-B[[3]]#1[[3]]^2  (*,5 #1[[4]]-#1[[4]]^2,
              6 #1[[5]]-#1[[5]]^2*) }];
      Print["Vi=",Vi[{x,y,z}]];
      
      (* *)
      
      Xall={x1,x2,x3  (* ,1.5  ,2 *)};
      XTopt={{0,0,0},{0,0,0}};
      T={t1,t2,t3};
      T2T={t1,t2,t3};
      Vv[x_]=Vi[Table[x,{i,n}]]; 
      (* Vv[x_]=Table[dd[[i]]+A[[i]]x-B[[i]]x^2/2,{i,n}];*)
      Usedgraphs={};
      Skippedgraphs={};
      Lowprofitvalidgraphs={};
      Print["Vv=",Vv[x]];
      
      
      (*  From the above valuations, 
        this module make the matrix of constraints\[GreaterEqual]0  to be \
satisfied by any solution x: *)
       VmatrotX[Vv_,Xcurr_,n_]:=
        Module[{Vooo,x},  PechMatr=True;  
           Nage=n;
          
          If[(Pechat), 
            Print["Preliminary 2: *********** start making Vls from Vi ***** \
Xcurr=" ,Xcurr]; ] ;
          (*Vooo[x_]=Vv[Table[x,{i,Nage}]];*)
          Vooo=Function[Vi[Xcurr]];
          If[(Pechat), Print[" Vooo[[1]]= ", Vi[{x1,x1,x1}][[2]] ]; ];
          Votx=Table[0,{i,Nage},{j,Nage}]; 
          For[i=1,i\[LessEqual]Nage,i++,(
              For[j=1,j\[LessEqual]Nage,j++,
                  (If[(i\[NotEqual] j),
                        (Votx[[i,j]]=
                            Vi[{Xcurr[[i]],Xcurr[[i]],Xcurr[[i]]}] [[i]]-
                              Vi[{Xcurr[[j]],Xcurr[[j]],Xcurr[[j]]}][[i]];
                          (*Print["Vooo[Xcurr[[j]]] [[i]]=", 
                                Vooo[Xcurr[[j]]] [[i]]];*) 
                          If[(False),
                            Print[i,j,"Votx[[i,j]]=",Votx[[i,j]] ,
                              ",  Vooo[Xcurr [[j]]]=",
                              Vo[Xcurr [[j]]] ]]; ),((*else*)Votx[[i,j]]=
                            Vooo[Xcurr[[i]]][[i]]-0;
                          If[(False),
                            Print[i,j,"diagVotx[[i,j]]=",
                              Votx[[i,j]] ]]; )];)];)];
          If[(Pech),Print["Votx=",MatrixForm[Votx]]];
          Return[Votx]; ];
      
      Print["  [Vv,#1 ,n]=",VmatrotX[Vv,Xall,n]];
      
      (* Now next module generates the constraints to be used later on, 
        in two forms:*)
      Constraints={}; 
      Constraints00ij=Table[0,{i,n},{i,n}];
      For[i=1, i\[LessEqual]n,i++,(
          For[j=1,j\[LessEqual]n,j++,(
              
              If[(i\[Equal]j),( 
                  Constraints=
                    Append[Constraints, 
                      Votx[[i,i]]-T[[i]]\[GreaterEqual] 0.001*rho];
                  
                  Constraints00ij[[i,j]]= 
                    Votx[[i,i]]-T[[i]]- 0.001*rho), (Constraints=
                    Append[Constraints, 
                      Votx[[i,j]]-T[[i]]+T[[j]]\[GreaterEqual]rho];
                  Constraints00ij[[i,j]]=  Votx[[i,j]]-T[[i]]+T[[j]]-rho)];
              )])];
      If[(Pech),Print["Constraints=", MatrixForm[Constraints]];
        Print["Constraints00ij=", MatrixForm[Constraints00ij]]];
      
      (*----------------------------------------------------------------------------*)
\

      (*  
        Preliminary 3: 
          Naive Floating Algorithm to make starting Plan and starting profit \
LowerBound *)
      (* Finding the lower bound on Profit through serving single consumers: 
                  Prof0=0;... deleted*)
      Vvnew={}; 
      Plan={{0,0,0},{0,0,0}};
      Vyp={};
      H={};X={};yakor={{0,0}};
      For[i=1, i\[LessEqual]n, 
        i++,( X=Append[X,A[[i]]/(2B[[i]])]; (* 
            absciss of peaks of initial parabolas-valuations *)
          
          H=Append[H,Vv[A[[i]]/(2B[[i]])][[i]]]; (* 
            heights of initial parabolas-valuations *)
          
          Vvnew=Append[Vvnew,Vv[x][[i]]-H[[i]]]; (* 
            reduced initial parabolas-valuations *)
          Vyp=Join[Vyp,{{H[[i]],X[[i]],Vvnew[[i]],i}}])];
      
      Vyp=Vyp[[Ordering[Vyp[[All,{1}]]]]]; (* sorted list of heights, Xs, 
        Valuations *)
      
      Vyp[[1,3]]=Vyp[[1,3]]+Vyp[[1,1]]; (* rised up first parabola *)
      Plan[[1,Vyp[[1,4]]]]=Vyp[[1,2]]; (* assigned X for first parabola *)
      Plan[[2,Vyp[[1,4]]]]=Vyp[[1,1]];  (* assigned T for first parabola *)
      yakor=Append[yakor,{Vyp[[1,2]],Vyp[[1,1]]}];
      
      Rasst={};
      For[i=2,i\[LessEqual]n,i++,(
          Rasst={};
          For[j=1,j\[LessEqual]Length[yakor],j++,(
              Rasstij=Abs[yakor[[j,2]]-Vyp[[i,3]]/.x-> yakor[[j,1]]];
              Rasst=Join[Rasst,{Rasstij}];
              )];
          Vyp[[i,3]]=Vyp[[i,3]]+Min[Rasst];
          
          yakor=Append[
              yakor,{Vyp[[i,2]],
                ReplaceAll[Vyp[[i,3]],{x-> Vyp[[i,2]]}]}];
          Plan[[1,Vyp[[i,4]]]]=yakor[[i+1,1]];
          Plan[[2,Vyp[[i,4]]]]=yakor[[i+1,2]];
          )];
      
      Vyp=Vyp[[Ordering[Vyp[[All,{4}]]]]];
      heightMax=Max[Plan[[2]]];
      xpeakMax=Max[Plan[[1]]];
      planTransp=Transpose[Plan];
      Xnaive=Plan[[1]];
      Tnaive=Plan[[2]];
      If[(Pechat),
        Print["Start finding a local optimum close to Naive Plan:"]];
      findmax1=
        FindMaximum[{(Mm[[1]]*t1+Mm[[2]]*t2+Mm[[3]]*t3),
            Constraints},{{x1,Xnaive[[1]]},{x2,Xnaive[[2]]},{x3,
              Xnaive[[3]]},{t1,Tnaive[[1]]},{t2,Tnaive[[2]]},{t3,
              Tnaive[[3]]}}];
      
      AdjMatrStart=Table[0,{i,n},{j,n}];
      AdjMatrStart44=Table[0,{i,n+1},{j,n+1}];
      Xoptstart={x1,x2,x3}/.findmax1[[2]];
      Toptstart={t1,t2,t3}/.findmax1[[2]];
      Uoptstart=findmax1[[1]];
      XTopt={Xoptstart,Toptstart};
      bestRiverStart={};
       For[i=1,i\[LessEqual]n,i++, (For[j=1,j\[LessEqual]n,j++,
            (If[(0\[Equal] 
                      Chop[(Constraints00ij[[i,j]]/.{x1-> Xoptstart[[1]],
                              x2-> Xoptstart[[2]],
                              x3-> Xoptstart[[3]],
                              t1-> Toptstart[[1]],t2-> Toptstart[[2]],
                              t3-> Toptstart[[3]]} ), 
                        0.000001] ),(AdjMatrStart[[i,j]]=1;  
                    If[(i\[Equal]j),( AdjMatrStart44[[i+1,1]]=i+1; 
                        bestRiverStart=
                          Append[bestRiverStart,{i+1,1}];),( (*else*) 
                        AdjMatrStart44[[i+1,j+1]]=i+1; 
                        bestRiverStart=
                          Append[bestRiverStart,{i+1,j+1}];)]) ]; )])]; 
      
      
      If[(Pechat),
        Print[MatrixForm[
            Chop[(Constraints00ij/.{x1-> Xoptstart[[1]],
                    x2-> Xoptstart[[2]],x3-> Xoptstart[[3]],
                    t1-> Toptstart[[1]],t2-> Toptstart[[2]],
                    t3-> Toptstart[[3]]} )]],"= Constraints00ij"];
        Print[ " bestRiverStart=",bestRiverStart];
        Print[MatrixForm[AdjMatrStart],"= AdjMatrStart"];
        Print[MatrixForm[AdjMatrStart44],"= AdjMatrStart44"] ];
      
      If[(Pechat),
        Print[Xoptstart,
          "= Xoptstart, is a local optimum close to Naive Plan, Toptstart=", 
          Toptstart]];
      NaivProfit=0;
      For[i=1,i\[LessEqual]n,i++,NaivProfit=NaivProfit+Mm[[i]]*Plan[[2,i]]];
      
      points0=
        Graphics[ {Circle[{Plan[[1,1]],Plan[[2,1]]},0.015], 
            Circle[{Plan[[1,2]],Plan[[2,2]]},0.015], 
            Circle[{Plan[[1,3]],Plan[[2,3]]},0.015]}];
      points11=
        Graphics[ {Disk[{Xoptstart[[1]],Toptstart[[1]]},0.015], 
            Disk[{Xoptstart[[2]],Toptstart[[2]]},0.015], 
            Disk[{Xoptstart[[3]],Toptstart[[3]]},0.015]}];
      Show[{Plot[{Vv[x][[1]],Vv[x][[2]],Vv[x][[3]]},{x,0,3},
                PlotStyle-> {Red,Green,Blue}, PlotRange->{0,1.5},
                PlotLabel-> {"3 Initial Valuations and NaivePlan "},
                PlotLabel-> {x,v}] (*,points0,points11*)}]
          
          (* MatrcesAdmissibUsed={};
            MatrcesAdmissibUsed=Append[MatrcesAdmissibUsed,AdjMatrStart44];*)
          
          Usedgraphs=Append[Usedgraphs,AdjMatrStart44];
      OptMat=AdjMatrStart44;
      Uopt=
        Uoptstart-0.000001;   (* -100 or better take   Uoptstart-0.000001*)  (* 
        approx starting value of Lower-Bound Uopt for main algorithm *)
      n=3; 
      (* LayMat[[1]]=Partns[[ipart,1]];
        If[(Length[Partns[[ipart ]]]>1),LayMat[[2]]=Partns[[ipart,2]]];
        If[(Length[Partns[[ipart ]]]>2),LayMat[[3]]=Partns[[ipart,3]]] ;*)
      
      Lbls=Table[i+1,{i,n }];
      Partns=SetPartitions[Lbls];
      PermuParts={}; 
      AllAdMatrs={};
      AllTrrivs={};
      (*PermPrts=Permutations[Partns];*)
      (*If[(Pechat),
          Print["- - - - Preliminary 4: now construct non-labelled partitions \
of n agents' types "];
          Print["Partns=",Partns]];
        
        Print["Length[SetPartitions[Lbls]]=",
          LenPart=Length[SetPartitions[Lbls]]];
        
        Print["PermPrts=",PermPrts];
        Print[ "..PermPrts,   Length[PermPrts]=",Length[PermPrts]];*)
      LayMat=Table[".",{i,1,n},{j,1,n}];
      NulMat=AdjMat=Table[0,{i,1,n+1},{j,1,n+1}];
       
       BadTrees={}; 
       IndxVersn =Table[1,{i,n+2}];
      try=1;itr=1; 
      IndxVersn[[1]]=0;IndxVersn[[n+2]]=0;
      ListAllTargsBel=Table[{0},{i,n+2}]; 
      (* <-for each agent, 
        his possible groups-sons will be here. How many versions-groups= *)
      LisLenAllVersBel=Table[0,{i,n+2}];
      Nskipped=0;
      Nonskipped=0;
      iadjmatr=1;
      nsolvedrivers=0;
      nsolvedtrees=0;
      nadmissgraphs=0;
      
      
      If[(Pechat),
        Print["--------Start main iterations checking Rivers \
one-by-one:----"]];
      (*----------------Start main iterations checking Rivers one-by-one,
        taking from--RiversList-------*)
      
      For[itriv=1,itriv\[LessEqual] lenRivList,itriv++, (
          rivTree=RiversList[[itriv]];
          If[(Pechat),Print[itriv,"=itriv,  rivTree=",rivTree]];
          
          AdjMat=NulMat;
          
          LerivTree=
            Length[rivTree];(*start making an Adjacency-Matrix from Tree*)
          For[i=1,i\[LessEqual]LerivTree,i++, (iojo=rivTree[[i]]; 
              AdjMat[[iojo[[1]],iojo[[2]]]]=rivTree[[i,1]];
              
              If[(Pech22),
                Print[i, "=i element of matrix, rivTree[[i]]=",rivTree[[i]] ,
                    ", AdjMat[[iojo[[1]] ]]= ",AdjMat[[iojo[[1]] ]]];]; )];
          curLenAlAdMat=Length[AllAdMatrs];
          
          
          If[(Pech11),
            Print[iadjmatr,"=iadjmatr, previous AllAdMatrs[[curLenAlAdMat]]=",
                MatrixForm[AllAdMatrs[[curLenAlAdMat]]],", new AdjMat= ",
                MatrixForm[AdjMat]];];
          iadjmatr=iadjmatr+1; 
          
          If[(MemberQ[AllAdMatrs,AdjMat]),
            If[(Pech11),(Print[ "==Yes. It is among previous." ];
                nsymmetrii=nsymmetrii+1;
                nAllsymmetrii=nAllsymmetrii+1;)],(*else*)(AllAdMatrs=
                Append[AllAdMatrs,AdjMat];
              
              AllTrrivs=Append[AllTrrivs,rivTree];(* 
                APreodTrrivs=Append[APreodTrrivs,rivTree];*) )];
          (*thus we have excluded repetitions, if any, 
            and supplemented list AllTrrivs of rivers with a new one, 
            new AdjacenyMatrix to be studied before building next one. *)
          
          (* Now try to solve optimal Xi for a tree or river, 
            when functions are quadratic and system linear: *)
          Lamb=Table[0,{i,n},{j,n}]; 
          DLt=Table[0,{i,n}]; (* derivatives of Lagrangian in T*)
          DLx=Table[0,{i,n}]; (* derivatives of Lagrangian in X*)
          T={t1,t2,t3}; (* vector of variables T*)
          Equations={}; (* = the name of the equations array to be formed *)
          
          Constr={};  (* = 
              the name of the graph-specific inequalities array to be formed *)
          
          solXTreal={};
          LamNeNul={};  (* =  the array of Lagrange multipliers *)
          ProfitReal={}; (* = attempted profit value *)
          Profit1={};    (* = attempted profit value *)
          
          Constraints1={};  (* = 
              the name of the inequalities array to be formed *)
          LamSuc=Table[0,{i,n}];
          LamPre=Table[0,{i,n}];
          LamPreVprim=Table[0,{i,n}];
          Msum=Table[Mm[[i]],{i,n}]; (* sum of masses *)
          Profitil=0;
          Rivergood=True;
          
          (*---------------------------------------------------------------*)
\

          
          
          If[(Sum[AdjMat[[i,j]],{i,2,n+1},{j,1,n+1}]\[Equal]
                Sum[ki,{ki,2,n+1}]),
            If[(Pechat),
              Print["GRAPH-Tree (necessarily new). We start solving it as \
tree:"]]; (* because the number of arcs is n. 
                  Then simpler sequential solution method: *)
            (nsolvedtrees=nsolvedtrees+1;
              For[j0=1,j0\[LessEqual] n,j0++,(
                  
                  j=n+2-j0;(*=cs of adjacency matrix, 
                    to find full weights:*) 
                  For[i=2,i\[LessEqual] n+1,i++,
                    
                    If[(AdjMat[[i,j]] \[NotEqual]  0),(Msum[[j-1]]=
                          Msum[[j-1]]+Msum[[(AdjMat[[i,j]]-1)]];
                        )];
                    ];
                  )];
              
              (* start making composite Profit-function[x] plugging t:*)
              Prof=Sum[Votx[[j,j]]*Mm[[j]],{j,1,n}];
              For[j0=1,j0\[LessEqual] n,j0++,(
                  
                  j=n+2-j0;(*=raws of adjacency matrix, 
                    to find full weights:*) 
                  For[i=2,i\[LessEqual] n+1,i++,
                    
                    If[(AdjMat[[i,j]] \[NotEqual]  0),(Prof=
                          Prof+(Votx[[j-1,j-1]]-
                                  ReplaceAll[
                                    Votx[[i-1,
                                      i-1]],{Xall[[i-1]]->  
                                        Xall[[j-1]]}])*Msum[[(i-1)]])];
                    ];
                  )];
               
              
              solX=Solve[{D[Prof,x1]\[Equal]0,D[Prof,x2]\[Equal]0,
                    D[Prof,x3]\[Equal]0},Xall];
              If[(Pechat),Print[ "solX=",solX   ], ", Prof=", Prof];
              
              
              listOfReadyT={};
              
              For[is=2,is\[LessEqual]n+1,
                is++,(If[(AdjMat[[is,1]]\[NotEqual]0),
                    T[[is-1]]=Votx[[is-1,is-1]];
                    listOfReadyT=Append[listOfReadyT,is];])];
              (* =prisvoili T cherez X,kto korniu zavoduet recursivno:*)
              
              For[nprosmotra=1,nprosmotra\[LessEqual]n,nprosmotra++,
                For[j=2,j\[LessEqual]n+1,
                  j++,(For[i=2,i\[LessEqual]n+1,
                      i++,(If[((AdjMat[[i,j]]\[NotEqual]0)&&(MemberQ[
                                  listOfReadyT,
                                  j])&&(!MemberQ[listOfReadyT,i])),
                          T[[i-1]]=
                            T[[j-1]]-
                              ReplaceAll[Votx[[i-1,i-1]],
                                Xall[[i-1]]-> Xall[[j-1]]]+
                              Votx[[i-1,i-1]];
                          listOfReadyT=Append[listOfReadyT,i];];)];)];];
              If[(Pechat),Print["listOfReadyT=",listOfReadyT,", T=",T]];
              
              
              
              TTn=Chop[T/.solX[[1]]];
              XXn=Chop[Xall/.solX[[1]]];
              
              If[(Pechat),
                Print[{T,Xall},"=T,Xall, po derevu TTn= ", TTn,", XXn= ", 
                  XXn]];
              
              
              Constraints1=Constraints;
              For[i=1, i\[LessEqual] n, i++, (
                  (*Constraints1=
                        Constraints1//.{T2T[[i]]-> TTn[[i]],
                            Xall[[i]]-> XXn[[i]]};*)
                  Constraints1=Constraints1/.T2T[[i]]-> T[[i]];
                  Chop[Constraints1];
                  )];
              
              (*Print["Constraints:", Constraints1];*)
              Constraints1=Constraints1/.solX[[1]];
              (*Print["Constraints:", Constraints1];*)
              
              validsolution=True;
              
              For[i=1, i\[LessEqual]  Length[Constraints1],i++, 
                If[(Constraints1[[i]]\[Equal] False), 
                  validsolution=False;
                  ]];
              
              Profitil=Prof/.solX ;
              If[(Pechat),
                Print[validsolution,
                  "= validsolution, currentNonadmissibleProfit= ", Profitil,
                  ", was admiss. payoff Uopt =", Uopt]];
              If[(validsolution),( (*then*)
                  If[(Pechat),Print["Yes,  Tree "]];
                   (* remember this graph not to study its relatives:*)  
                   Usedgraphs=Append[Usedgraphs,AdjMat];
                  lenUsedgraphs=Length[Usedgraphs];
                  nadmissgraphs=nadmissgraphs+1;
                  If[(Profitil[[1]]>Uopt), (
                      If[(validsolution),( 
                            Uopt= Profitil[[1]];
                            XTopt={XXn,TTn};
                            OptMat=AdjMat; 
                            If[(Pechat),Print["  validgoodsolution "];
                              
                              Print["used or lowprofit  ",
                                MatrixForm[AdjMat]]];),  
                          (*else*)Print["tree-SOLUTIONS ABSENT!??"]];), 
                    ( (*else lowprofit and ..:*)  
                      
                      Lowprofitvalidgraphs=
                          Append[Lowprofitvalidgraphs,AdjMat];
                       )]),
                ((*if nonvalidsolution*) 
                  If[(Pech11), Print["tree-SOLUTION nonvalid!"]];)];
              
              )
            
            (*----------else----graph not a tree:------*)
            ,
            (
               
              If[(Pechat),
                Print["GRAPH-nontreeRiver, start solving it through quadratic \
simultaneous equations:"]];
              
              
              Rivergood=True; (* 
                start checking is the river new and promising or to-be-
                  rejected because old or a descendent-
                  relative of an old admissible graph with low profit: *)
              
              (*duplicated in Rivers, 
                so one cycle switched off:  
                      For[i=1, i\[LessEqual]Length[BadTrees], i++, 
                        If[(Min[AdjMat-BadTrees[[i]]]\[GreaterEqual]0),
                          (*  Rivergood=False;   *) Nskipped=Nskipped+1;]]; *)
              
              innonskip=True ;
              If[(Rivergood),(
                  
                  For[i=1, i\[LessEqual]Length[Usedgraphs], i++,
                    If[(Min[AdjMat-Usedgraphs[[i]]]\[GreaterEqual]0), ( 
                        innonskip=False; 
                        (*  
                          Rivergood=False; =
                            temporary switched-off economizing-
                              command because something goes wrong with it. 
                                  In principle, 
                          it should economize computer efforts. 
                              We calculate how many rivers we should (but \
dont so far) pass without solving: *)   i=i)]];
                  
                  
                  If[(innonskip),(Nonskipped=Nonskipped+1;),(*else*) 
                    Nskipped=Nskipped+1;  
                    
                    Skippedgraphs=Append[Skippedgraphs,AdjMat];
                    
                    If[(Pechat),
                      Print[itriv,"=itriv, added Nskipped=",Nskipped,
                        ", Length[Usedgraphs]=",Length[Usedgraphs]]];];
                  Eqntop={};
                  jNonenvied={}; (*list of iNonenvied agents: *)
                  (* 
                    start forming the list of nonzero Lagrange lambdas and \
graph-specific constraints-equalities each (i,j) of graph, 
                    and list of iNonenvied agents: *)
                  
                  If[(Rivergood &&  innonskip),(nsolvedrivers=
                        nsolvedrivers+1;
                      For[j0=1,j0\[LessEqual] n,j0++,(
                          
                          j=n+2-j0;(*=columns of adjacency matrix, 
                            to find full weights:*) 
                          
                          If[(Sum[
                                  AdjMat[[i,j]],{i,2,
                                    n+1}]\[Equal]0),(jNonenvied=
                                Append[jNonenvied,j-1];
                              
                              Eqntop=
                                Append[Eqntop, 
                                  D[Vv[Xall[[j-1]]][[j-1]],
                                      Xall[[j-1]]]\[Equal]0 ];
                              If[(Pechat),
                                Print[j,
                                  "=j top-tree agent non-envied Eqntop=",
                                  Eqntop]])];
                          For[i=2,i\[LessEqual] n+1,i++,
                            If[(AdjMat[[i,j]] \[NotEqual]  0),(
                                  
                                  Lamb[[i-1,j-1]]=
                                    StringExpression["la",ToString[i-1],
                                      ToString[j-1]];
                                  
                                  LamNeNul=
                                    Append[LamNeNul,
                                      ToExpression[Lamb[[i-1,j-1]]]];
                                   
                                  Constr=
                                    Append[
                                      Constr,(Votx[[i-1,j-1]]-T[[i-1]]+
                                        T[[j-1]]\[Equal]0)];
                                   )];
                            ];
                          )];
                      
                      (*start forming excessive equations system with top xi \
determined just now:*) 
                      Equations=Eqntop;
                      
                      
                      For[i=2,i\[LessEqual] n+1,
                        i++,(*=making names of diagonal elements lambda:*)
                        If[(AdjMat[[i,1]] \[NotEqual]  0),(
                              
                              Lamb[[i-1,i-1]]=
                                StringExpression["la",ToString[i-1],
                                  ToString[0]];
                              
                              LamSuc[[i-1]]=
                                LamSuc[[i-1]]+ToExpression[Lamb[[i-1,i-1]]];
                              
                              LamNeNul=
                                Append[LamNeNul,
                                  ToExpression[Lamb[[i-1,i-1]]]];
                              
                              Constr=
                                Append[
                                  Constr,(Votx[[i-1,i-1]]-
                                        T[[i-1]]\[Equal]0)];)];];
                      
                      If[(False),Print[i,  "=i, LamSuc[[i-1]]=",LamSuc ]];
                      
                      
                      For[i=2,i\[LessEqual] n+1,
                        i++,( (*=
                              making Lambda Successors and predecessors:*)
                          (*=raws of adjacency matrix, 
                            to find lambda weights:*) 
                          For[ j=1,j\[LessEqual] n+1,j++, 
                            
                            If[(AdjMat[[i,j]] \[NotEqual]  
                                  0 ),(LamSuc[[i-1]]=LamSuc[[i-1]]+
                                      
                                      If[(j\[NotEqual]  1 ),(ToExpression[
                                        Lamb[[i-1,j-1]]]),(0)];
                                 )];
                            
                            
                            If[(AdjMat[[j,i]] \[NotEqual]  
                                  0 ),(LamPre[[i-1]]=LamPre[[i-1]]+
                                      
                                      If[(j\[NotEqual]  1 ),(ToExpression[
                                        Lamb[[j-1,i-1]]]),(0)]; 
                                  LamPreVprim[[i-1]]=LamPreVprim[[i-1]]+
                                      
                                      If[(j\[NotEqual]  
                                        1 ),(ToExpression[Lamb[[j-1,i-1]]]*
                                        D[ReplaceAll[Votx[[j-1,j-1]],
                                        Xall[[j-1]]->  Xall[[i-1]]],
                                         Xall[[i-1]]]),(0)]);
                              ];
                            ];
                          (* 
                            differentiating the Lagrangian in ti we find \
lambdas-equations:*)
                          DLt[[i-1]]=Mm[[i-1]]-LamSuc[[i-1]]+LamPre[[i-1]];
                          (* 
                            differentiating the Lagrangian in xi we find xs-
                              equations:*)
                              DLx[[i-1]]=D[Votx[[i-1,i-1]],
                                  Xall[[i-1]]]*LamSuc[[i-1]]-
                              LamPreVprim[[i-1]];
                          (*   take together all equations:*)
                          Equations=Append[Equations,DLt[[i-1]]\[Equal]0];
                          Equations=Append[Equations,DLx[[i-1]]\[Equal]0];
                          ;)
                        ];
                      
                      (* 
                        join equations-of-differentiation with constraints-
                          equalities:*)
                       Equations=Join[Equations,Constr];
                      XT=Join[Xall,T,LamNeNul];
                      
                      (* MAIN SOLVING operation may be NSolve?? *)
                      solXTlam=Solve[Equations ]; 
                      (* here was ,XT =nonrequired names of variables, 
                        omitted when number of equalities equal or greater \
than number of unknowns in them *)
                      solXT={Xall,T,LamNeNul}/.solXTlam;
                      (* = array of all roots obtained, 
                        where lambdas may be indefinite. It is 3-
                          dimensional matrix: roots, category X T or L, 
                        and member *)
                      lenLamNeNul=Length[LamNeNul];
                      nulLen=Table[0,{i,lenLamNeNul}];
                      
                      
                      solXTmax={};
                      (* 
                        Selecting among the obtained roots: ind=
                          1 means good root. *)
                      For [i=1, i\[LessEqual] Length[solXT], i++,
                        ind=1; 
                        
                        For[j=1,j\[LessEqual]n, j++,
                          If[(Head[solXT[[i,1,j]]]\[Equal] Complex),ind=0 ];
                            ; ];
                        
                        If[(ind\[Equal]1),(
                            Nerav={}; priznakLambd=True;
                            solXTmax=Join[solXTmax,{solXT[[i]]}];
                            For[j=1, j\[LessEqual] lenLamNeNul, j++, 
                              
                              Nerav=Join[
                                  Nerav,{solXT[[i,3,j]]\[GreaterEqual]0}]];
                            
                            (* priznakLambd=Reduce[Nerav,LamNeNul];
                              
                              this finds positivity of lambdas=
                                solXT[[i,3,..]]..Print["Nerav=", Nerav]; 
                              
                              maybe? 
                                  not to check any more positivity of lambdas \
because they are sometimes indtermined,
                              
                              whereas admissible X and T anyway can serve as \
solution
                               *)
                            
                            MinX=Min[solXT[[i,1]]];MinT=Min[solXT[[i,2]]];
                            For[j=1,j\[LessEqual]n, j++,
                              
                              If[(MinX<0)||(MinT<
                                      0)||(priznakLambd\[Equal]False) ,
                                ind=0 ]; (*this rejects negative X and T*)
                              ; ];)];
                        
                        If[(ind==1), 
                          solXTreal=Join[solXTreal,{solXT[[i]]}];];
                        ];
                      
                      If[(solXTreal\[NotEqual] {}), 
                        (* 
                          then start chacking admissibility of X and T within \
out-of graph inequalities: *)
                        For[i=1, i\[LessEqual] Length[solXTreal], i++,(
                              Constraints1=Constraints;
                               
                              For[j=1, j\[LessEqual]n, j++, 
                                Constraints1=
                                  Constraints1//.{Xall[[j]]-> 
                                        solXTreal[[i,1,j]], 
                                      T2T[[j]]-> solXTreal[[i,2,j]]};
                                (* here we have plugged magnitudes X,
                                  T found - into the constraints, 
                                  which becomes True or False each and check: \
*)
                                Chop[Constraints1];
                                
                                If[(Pechat),
                                  Print["Constraints1=", Constraints1]];];
                              solutGood=True;
                              
                              For[k=1, k\[LessEqual]Length[Constraints1], 
                                k++,
                                solutGood=solutGood && Constraints1[[k]];
                                (* 
                                  here we make False if any constraint is \
False, then variable  solutGood becomes False and solXTreal[[i]]={}*)
                                ];
                              If[!solutGood,solXTreal[[i]]={}];
                              )];];
                      
                      If[solXTreal\[Equal]{{}}, solXTreal={}];
                      If[solXTreal\[Equal]{{},{}}, solXTreal={}];
                      (*If[solXTmax\[Equal]{{}}, solXTmax={}];
                        If[solXTmax\[Equal]{{},{}}, solXTmax={}];*)
                      
                      
                      ProfitMax={};
                      For[i=1, i\[LessEqual]Length[solXTmax], i++, (
                          If[(solXTmax[[i]]\[NotEqual]{}),
                            (* 
                              then it means Real-
                                validsolution (wihin constraints) and we \
compare profits: *)   
                            
                             
                            ProfitMax=
                                Append[ProfitMax, 
                                  Sum[Mm[[j]]*solXTmax[[i,2,j]],{j,1,n} ]];,
                            (*else*)Append[ProfitMax,-100]; ])];
                      
                      If[(Pech11),Print["solXTlam=",solXTlam];
                        
                        Print["solX[[1,1]]=",solXT[[1,1]],"solT[[1,2]]=",
                          solXT[[1,2]]  ];
                        
                        If[(Length[solXT]>1),
                          Print["solX[[2,1]]=",solXT[[2,1]],"solT[[2,2]]=",
                            solXT[[2,2]] ] ];
                        Print["solXTreal=", solXTreal];];
                      
                      If[(Pech11),
                        Print[ "Lamb=",MatrixForm[Lamb],", Equations=",
                            Equations,", LamNeNul=",LamNeNul];];
                      
                      
                      If[(Pechat),
                        Print[ 
                          "nontree-river if not for constraints, its \
ProfitMax= ", ProfitMax,", previous was  Uopt=",Uopt]];
                      
                      If[(solXTreal\[NotEqual]{}) ,( (*then valid solution, 
                            make vector profits of vectors roots system:*)
                          If[(Pechat),Print["Yes,  validsolution river " ]];
                          nadmissgraphs=nadmissgraphs+1;
                          For[i=1, i\[LessEqual]Length[solXTreal], i++, (
                              If[(solXTreal[[i]]\[NotEqual]{}),
                                 
                                ProfitReal=
                                    Append[ProfitReal, 
                                      Sum[Mm[[j]]*solXTreal[[i,2,j]],{j,1,
                                        n} ]]; (* 
                                  ProfitReal accumulates all reav-
                                    valued attempts to improve:*)
                                ,
                                (*else*)Append[ProfitReal,-100]; ])];
                          
                          lenProfit=Length[ProfitReal];
                          iBest=Ordering[ProfitReal][[lenProfit]];
                          Bestsol=solXTreal[[iBest]];
                          
                          
                          If[(Pechat), 
                            Print["Best profit: ", ProfitReal[[iBest]], 
                              " attained at solution:", 
                              solXTreal[[iBest]]]];
                          If[ProfitReal[[iBest]]>Uopt, 
                            (Uopt=ProfitReal[[iBest]];
                              OptMat=AdjMat;
                              XTopt=solXTreal[[iBest]];
                              Print["**** better !  New  Uopt=",Uopt])];
                          
                          Usedgraphs=Append[Usedgraphs,AdjMat];
                          lenUsedgraphs=Length[Usedgraphs];)
                        ,
                        (*else*)  If[(Pechat), Print["SOLUTIONS ABSENT!"]]];
                      
                      If[(Max[ProfitMax]<Uopt),(
                          
                          Lowprofitvalidgraphs=
                              Append[Lowprofitvalidgraphs,AdjMat];)];
                      
                      )];
                  )]     )];
          
          (*----------------------------------------------------*)
          
          
          If[(Pech), Print[ " , rivTree=", rivTree ];
            Print[ "  AdjMat=", MatrixForm[AdjMat ]]];
          
          (* 
            Now we renew a delicate thing: IndxVersn= 
              IndxVersn-of-
                version of river within the current Preorder. 
                    It is increased by 1. But it is a vector, 
            each component being limited from above by number \
(LisLenAllVersBel[[i]]). So, when no room for increasing 1-st component, 
            we make it=1, and try to increase the 2-nd, and so on. *)
          
          For[i=2,i\[LessEqual]n,i++,
            If[(IndxVersn[[i]]+1\[LessEqual] LisLenAllVersBel[[i]]),
                IndxVersn[[i]] =IndxVersn[[i]]+1;Goto[outi],(*else*)
                
                If[(IndxVersn[[i+1]]+1\[LessEqual] 
                        LisLenAllVersBel[[i+1]]),(IndxVersn[[i+1]] =
                        IndxVersn[[i+1]]+1;
                      For[k=2,k\[LessEqual]i,k++,IndxVersn[[k]] =1];
                      Goto[outi];)];];];Label[outi];
          try=try+1;
          
          If[(try\[LessEqual] manyVers)(*=index-or-permutiterator*),(Goto[
                startipreodr])];
          LenPreodRvrs=Length[APreodTrrivs];
          AllPreodTrrivs=Join[AllPreodTrrivs,APreodTrrivs];
          
          If[(Pech11),
            Print[nsymmetrii,"=nsymmetrii,  APreodTrrivs=",nonprint,
              ", LenPreodRvrs=",LenPreodRvrs]];
          
          (* 
            Print["  AllAdMatrs=",AllAdMatrs," , LenMaTrs=",
                Length[AllAdMatrs]];*) )];
      
      
      Print["=******=ku-ku end=******,nAllsymmetrii=",nAllsymmetrii];
      LenAlTrvrs=Length[AllTrrivs];
      (*Print["  AllTrrivs=",AllTrrivs,", LenAlTrvrs=",LenAlTrvrs];
        Print["  AllAdMatrs=",AllAdMatrs," , LenMaTrs=",Length[AllAdMatrs]];*)
      
      Print["how many graphs should be skipped without solving: Nskipped=", 
        Nskipped];
      Print["approx Uopt= ",Uopt, ", XTopt= ", XTopt];
      Print[ "        OptMat=", MatrixForm[OptMat ]];
      
      Print[" AdjMatrStart44=",MatrixForm[AdjMatrStart44],"= compare them?"];
      If[(OptMat\[Equal] AdjMatrStart44),( 
          Print["Starting plan occurs Optimal"]; 
          ntimesstartopt=ntimesstartopt+1;
          ntimesstartoptAll=ntimesstartoptAll+1),( 
          Print["Starting plan occurs non-Optimal"];)];
      
      nAllRandskipped=nAllRandskipped+Nskipped;
      
      Print[
        "Start finetuning this true local optimum to increase machine \
precision:"];
      findmax2=
        FindMaximum[{(Mm[[1]]*t1+Mm[[2]]*t2+Mm[[3]]*t3),
            Constraints},{{x1,XTopt[[1,1]]},{x2,XTopt[[1,2]]},{x3,
              XTopt[[1,3]]},{t1,XTopt[[2,1]]},{t2,XTopt[[2,2]]},{t3,
              XTopt[[2,3]]}}, AccuracyGoal->  8, PrecisionGoal->  8, 
          MaxIterations-> 30];
      Xoptuned={x1,x2,x3}/.findmax2[[2]];
      Toptuned={t1,t2,t3}/.findmax2[[2]];
      Uoptuned=findmax2[[1]];
      
      xx1=XTopt[[1,1]];xx2=XTopt[[1,2]];xx3=XTopt[[1,3]];
      {xx1,xx2,xx3}=XTopt[[1]];
      {tt1,tt2,tt3}=XTopt[[2]];
      tt1=XTopt[[2,1]];tt2=XTopt[[2,2]];tt3=XTopt[[2,3]];
      tmax=Max[tt1,tt2,tt3];
      xoptMax=Max[xx1,xx2,xx3];
      Surpl={Vv[xx1][[1]]-tt1,Vv[xx2][[2]]-tt2,Vv[xx3][[3]]-tt3};
      points=Graphics[ {Circle[{xx1,tt1},0.015], Circle[{xx2,tt2},0.015], 
            Circle[{xx3,tt3},0.015]}];
      Print["{xx1,xx2,xx3}=",{xx1,xx2,xx3},", {tt1,tt2,tt3}=",{tt1,tt2,tt3},
        ", points=",points];
      
      Show[{Plot[{Vv[x][[1]]-Surpl[[1]],Vv[x][[2]]-Surpl[[2]],
              Vv[x][[3]]-Surpl[[3]]},{x,0,xoptMax*1.5},
            PlotStyle->{Red,Green,Blue},PlotRange-> {0,tmax*1.3},
            AxesLabel-> {x,t}, PlotLabel-> "FineTuned Optimum", 
            DisplayFunction-> Identity],points},
        DisplayFunction->$DisplayFunction] ;
      
      heightMax2=Max[tt1,tt2,tt3];
      pointsPlan=
        Graphics[{Point[planTransp[[1]]],Point[planTransp[[2]]],
            Point[planTransp[[3]]]}];
      Print["how many rivers should be skipped without solving Nskipped= ", 
        Nskipped,", solved Nonskipped= ", Nonskipped ];
      Print["========finish==iterand=" ];
       )];

Print["Naive Plan=",Plan,",  NaivProfit=",NaivProfit];
Print[Uoptstart,"=Uoptstart, Initial local-opt Plan Xoptstart=",Xoptstart,
    " ,  Toptstart=",Toptstart];
Print["apprx Uopt= ",Uopt,
    ", apprx Optimal plan  {xx1,xx2,xx3}=",{xx1,xx2,xx3},
    ", {tt1,tt2,tt3} =",{tt1,tt2,tt3}];
Print[ "Uoptuned= ",Uoptuned," tuned Optimal plan  Xoptuned=",Xoptuned,
    ", Toptuned=",Toptuned];
Print["Difference% relative= (Uoptuned-Uoptstart)/Uoptstart=  ",
    100 (Uoptuned-Uoptstart)/Uoptstart,"%"];
lenAllPreodTrrivs=Length[AllPreodTrrivs];
Print["how many rivers should be skipped without solving Nskipped= ", 
    Nskipped,", all nAllRandskipped= ",  nAllRandskipped];
Print["how many grpahs solved without skipping: nsolvedrivers= ",
    nsolvedrivers, "+",nsolvedtrees,"=nsolvedtrees "];
Print["= =========finish====March 2016====  =" ];

Show[{Plot[{Vyp[[1,3]],Vyp[[2,3]],Vyp[[3,3]],Vv[x][[3]]-Surpl[[3]]},{x,0,
        xpeakMax*1.5},
      PlotStyle->{Red,Green,Blue,{Dashing[{0.03,0.05}], Blue}},
      PlotRange-> {0,heightMax2*1.2},AxesLabel-> {x,t}, 
      PlotLabel-> "Naive and FineTuned StartingPlan",
      DisplayFunction-> Identity],pointsPlan,points11},
  DisplayFunction->$DisplayFunction] 
Print["how many ADMISSIBLE grpahs (non-contradictory active constraints) \
found: nadmissgraphs= ",nadmissgraphs,",   ntimesstartoptAll=",
    ntimesstartoptAll]; 
Print[niterRa,
    "=niterRa, how many rivers among (niterRa) examples skipped without \
solving nAllRandskipped/(79*niterRa)= ", nAllRandskipped/(79*niterRa),
    ", all nAllRandskipped= ",  nAllRandskipped];

Print["==========finish========="];

EndPackage; 

Online Appendix for "Digraph Algorithm for Screening"

 Файл (PDF, 339 Кб)


Online Appendix for "Chain-store against manufacturers..." Bykadorov et al.

 Файл (PDF, 232 Кб)

 

Timetable for today

Full timetable