• A
  • A
  • A
  • АБВ
  • АБВ
  • АБВ
  • А
  • А
  • А
  • А
  • А
Обычная версия сайта
Владение языками
английский
японский
Контакты
Электронная почта:
Адрес: Новосибирск, 630090, пр.ак.Коптюга 4, Институт математики СОРАН; Санкт-Петербург, 10я линия Васильевского острова 3, НИУ ВШЭ
Расписание
Резюме (DOC, 48 Кб)
SPIN РИНЦ: 9392-4269
ORCID: 0000-0002-1494-8295
ResearcherID: K-5517-2015
Scopus AuthorID: 23392413500
Google Scholar
Часы работы
11:00 - 23:00
Руководители
Тисс Ж.-Ф.
Кичко С. И.
Версия для печати

 

Нашли опечатку?
Выделите её, нажмите Ctrl+Enter и отправьте нам уведомление. Спасибо за участие!

Коковин Сергей Гелиевич

  • Начал работать в НИУ ВШЭ в 2010 году.
  • Научно-педагогический стаж: 26 лет.

Образование, учёные степени и учёные звания

  • 1998
    Ученое звание: Доцент
  • 1996

    Кандидат физико-математических наук: Центральный экономико–математический институт АН СССР, специальность 08.00.13 «Математические и инструментальные методы экономики», тема диссертации: Равновесия рынков с издержками сдержек и рационированием

  • 1981

    Специалитет: Новосибирский государственный университет им. Ленинского комсомола, специальность «Экономическая кибернетика»

  • 1981

    Специалитет: Новосибирский государственный университет им. Ленинского комсомола, специальность «экономическая кибернетика»

Профессиональные интересы

Учебные курсы (2016/2017 уч. год)

Учебные курсы (2015/2016 уч. год)

Учебные курсы (2014/2015 уч. год)

Analysis of Imperfect Markets (Бакалавриат; где читается: Санкт-Петербургская школа экономики и менеджмента; программа "Экономика"; 3-й курс, 3 модуль)

Учебные курсы (2012/2013 уч. год)

Анализ несовершенных рынков (Бакалавриат; где читается: Факультет экономики (Санкт-Петербург); 3-й курс, 2, 3 модуль)

Учебные курсы (2011/2012 уч. год)

Публикации26

Научный руководитель диссертационных исследований

на соискание учёной степени кандидата наук

Online-Appendix for "Retailer-Leader"

Разное

(2006-2007) EERC  Research Grant 06-0561 "Efficiency, over and underprovision in package pricing: diagnosis and price of regulation"

Разное

Исследовательский грант  12-06-00174-а РФФИ на 2012-2014: "Модели эндогенных рыночных структур, международной торговли и экономической географии", руководитель

"Vanishing Cities" submitted to J. of Regional Science

Catastrophes in Monopolistic Competition

Generating Graphs For Screening Optimization (Wolfram-Mathem. 2014)

 
(*
(* recallusefulcomands : AlternatingGroup[3]; KSubsetGroup[1, 2]; 
  Abc = {a, b, c}, Necklaces[Abc]; Tuples[{a, b}, 4];
    Print["Subsets=", Subsets[Abc]];
  Print["GrayCode=", GrayCodeSubsets[{1, 2, 3, 4}]];
  Print["Sected1GrayCode=", Delete[GrayCodeSubsets[{1, 2, 3, 4}], 1]] ; 
  RemoveMultipleEdges[]
  This is FULL version with branch - n - bounds and Naive*)

(* Hint : First open BeginPackage["Temporary`"];  << 
    DiscreteMath`Combinatorica`; then, in next Run of Proga, remove both .., 
  then you work always in one block with Context "Temporary`" 
    chtob ne cyclil : VKLIUCHIT Pech33, potom otkliuchiti *)
BeginPackage["Temporary`"];  << DiscreteMath`Combinatorica`;
  (* This program = 
      Layers - method for building all rivers from all trees and enumerating \
them. It works like this : 
            We take labelled nodes {1, 2, ..., n} of a would - 
              be digraph. Connecting the nodes, 
    we build all possible trees one - by - one, 
    classifying them into families of longest - path - 
      layers (see paper ScreeningStructures.tex). After building a tree, 
    it enriches each tree with bypasses to get relatives of this tree : 
        river - family. But we should exclude intersections. Namely, 
    from each tree, we try ALL bypasses downstream, 
    throwing away rivers with the same unique INDEX as existed previously! 
    Preorder - vector makes INDEX 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 becomes ``full'' we make it empty and the next layer \
gets + 1. Like decimal numbers, but n - imal instead of decimal, 
    and rightmost = biggest.
              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  (*, 4 , 5 *)}; 
    
    A = {1.0, 0.8, 1.2};
    B = {1.2, 1.0, 1.7};
    dd = {0, 0, 0};
    Mm = {1, 1, 2}; - primer kogda funkciya pribily vipyklaya  
    *)
  
  
  
  
  
  
  
  
  ClearAll[Partns, Layers, LayMat, AdjMat, i, j, k, n, AllAdMatrs];
  Pech = False (* False True*); Pech11 = False (* False True*); 
  Pech22 = False (* False True*);
  Pech33 = False;
  
  (*Proga for solving Tree - optimization through differentiating Pi*)
  n = 3; (*data d + ax - bx^2/2 *) 
  ClearAll[A, B, dd, Vo, Votx, Vi, Vv, Mm, Xcurr];
  A = {3.0, 1.8, 3.2};
  B = {1.6, 2.3, 0.4};
  dd = {0, 0, 0};
  Mm = {3, 0.5, 2  (*, 4 , 5 *)};  Uopt = -100;
  rho = -0.00001;
  
  NN = 2;
  Nraz = 0;
  Nobshskipped = 0.0;
  Nsred = 0.0;
  Raznobsh = 0;
  Npopali = 0;
  
  For[Nex = 1, Nex <= NN, Nex++, (
      Print["Nex=", Nex];
      
      Mm[[1]] = 0.1 + Random[];
      Mm[[2]] = 0.1 + Random[];
      Mm[[3]] = 0.1 + Random[];
      A[[1]] = 0.1 + Random[];
      A[[2]] = 0.1 + Random[];
      A[[3]] = 0.1 + Random[];
      B[[1]] = 0.1 + Random[];
      B[[2]] = 0.1 + Random[];
      B[[3]] = 0.1 + Random[];
      
      Uopt = -100;
      
      If[(A[[1]] != A[[2]]) && (A[[2]] != A[[3]]) && (A[[1]] != 
              A[[3]]) && (B[[1]] != B[[3]]) && (B[[1]] != 
              B[[3]]) && (B[[1]] != B[[3]]), (ClearAll[Vo, Votx, Vi, Vv, 
            Xcurr];
          ClearAll[Partns, Layers, LayMat, AdjMat, i, j, k, AllAdMatrs];
          
          
          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*) }];
          If[(Pech33), Print["Vi=", Vi[{a, b, c}]]];
          
          
          Xstart = {x1, x2, x3  (* , 1.5  , 2 *)};
          Xopt = {};
          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}];*)
          If[(Pech33), (Print["Vv=", Vv[x]];
              
              Plot[{Vv[x][[1]], Vv[x][[2]], Vv[x][[3]]}, {x, 0, 3}, 
                PlotStyle -> {Red, Green, Blue}];)];
          
           VmatrotX[Vv_, Xcurr_, n_] :=
            Module[{Vooo, x}, Pechat = False; PechMatr = False;  
               Nage = n;
              
              If[(Pechat), 
                Print[" *********** 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 <= Nage, i++, (
                  For[j = 1, j <= Nage, j++,
                      (If[(i != 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[(True), Print["Votx=", MatrixForm[Votx]]];
              Return[Votx]; ];
          
          If[(True), Print["\!\(\*
StyleBox[\"VmatrotX\",\nFontColor->RGBColor[0, 0, 1]]\)[Vv,#1 ,n]=", VmatrotX[Vv, Xstart, n]]];
          
          Constraints = {}; 
          
          For[i = 1, i <= n, i++, (
              For[j = 1, j <= n, j++, (
                  
                  If[(i == j), 
                      Constraints = 
                        Append[Constraints, Votx[[i, i]] - T[[i]] >= rho], 
                      Constraints = 
                        Append[Constraints, 
                          Votx[[i, j]] - T[[i]] + T[[j]] >= rho]];)])];
          If[(Pech33), Print["Constraints=", MatrixForm[Constraints]]];
          
          
          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 = {};
          If[(Pech33), (Print["Partns=", Partns];
              
              Print["Length[SetPartitions[Lbls]]=", 
                LenPart = Length[SetPartitions[Lbls]]];)];
          PermPrts = Permutations[Partns];
          
          If[(Pech33), 
            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}];
          LayMat[[1]] = Lbls;
          
          If[(Pech33), 
            Print["LenPart=", LenPart, ", LayMat=", MatrixForm[LayMat]]];
          
          (* 
            Finding the lower bound on Profit through serving single \
consumers : Prof0 = 0; ... udaleno*)
          
          
          For[ipart = 1, ipart <= LenPart, ipart++, (
              PermPrts = Permutations[Partns[[ipart ]] ];
              PermuParts = Join[PermuParts, PermPrts];
              )];
          If[(Pech33), (Print[ "... PermuParts=", PermuParts ];
              Print["Length[PermuParts]=", LenPerPar = Length[PermuParts]])];
          
          AllTrrivs = {};(* Having all Permutations of Partitions = Layers, 
            
            we take each Permutation No "ipreodr" and make a tree or several \
from it *)
          nAllsymmetrii = 0;
          BadTrees = {};
          BadRivers = {};
          Nskipped = 0;
          
          (*----------------------------------------------------------------------------*)
\

          (*Naivniy Algoritm*)
          Vvnew = {}; 
          AdjNaiv = NulMat;
          Plan = {{0, 0, 0}, {0, 0, 0}};
          Vyp = {};
          H = {}; X = {}; yakor = {{0, 0}};
          For[i = 1, i <= n, i++, ( X = Append[X, A[[i]]/(2B[[i]])];
              H = Append[H, Vv[A[[i]]/(2B[[i]])][[i]]];
              Vvnew = Append[Vvnew, Vv[x][[i]] - H[[i]]];
              Vyp = Join[Vyp, {{H[[i]], X[[i]], Vvnew[[i]], i}}])];
          
          Vyp = Vyp[[Ordering[Vyp[[All, {1}]]]]];
          
          Vyp[[1, 3]] = Vyp[[1, 3]] + Vyp[[1, 1]];
          Plan[[1, Vyp[[1, 4]]]] = Vyp[[1, 2]]; 
          Plan[[2, Vyp[[1, 4]]]] = Vyp[[1, 1]];
          yakor = Append[yakor, {Vyp[[1, 2]], Vyp[[1, 1]]}];
          
          Rasst = {};
          For[i = 2, i <= n, i++, (
              Rasst = {};
              For[j = 1, j <= 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]]}]}];
              Vyp[[i, 1]] = yakor[[i + 1, 2]];
              Plan[[1, Vyp[[i, 4]]]] = yakor[[i + 1, 1]]; 
              Plan[[2, Vyp[[i, 4]]]] = yakor[[i + 1, 2]];
              )];
          
          For[i = n, i >= 1, i--, (
              
              If[(*Abs[Vyp[[i, 3]] /. x -> Vyp[[i, 2]]] <= 
                    0.01*)(Vv[Vyp[[i, 2]]][[Vyp[[i, 4]]]] == Vyp[[i, 1]]), (
                  AdjNaiv[[Vyp[[i, 4]] + 1, 1]] = Vyp[[i, 4]] + 1;
                  ), (
                  
                  AdjNaiv[[Vyp[[i, 4]] + 1, Vyp[[i - 1, 4]] + 1]] = 
                      Vyp[[i, 4]] + 1;
                  )])];
          If[(Pech33), Print["AdjNaiv=", MatrixForm[AdjNaiv]]];
          
          Vyp = Vyp[[Ordering[Vyp[[All, {4}]]]]];
          heightMax = Max[Plan[[2]]];
          xpeakMax = Max[Plan[[1]]];
          planTransp = Transpose[Plan];
          
          
          NaivPrib = 0;
          
          For[i = 1, i <= n, i++, 
            NaivPrib = NaivPrib + Mm[[i]]*Plan[[2, i]]];
          (*-------------------------------------------------------------------------\
*)
          
          For[ipreodr = 1, ipreodr <= LenPerPar (* LenPerPar*) , ipreodr++, (
              If[(Pech11), Print[ ipreodr , "=ipreodr =======\!\(\*
StyleBox[\"new\",\nFontColor->RGBColor[1, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[1, 0, 1]]\)\!\(\*
StyleBox[\"Preorder\",\nFontColor->RGBColor[1, 0, 1]]\) (iLayers) structure============" ]];
              nsymmetrii = 0;
              BadTrees = {};
              BadRivers = {};
              iLayers = Join[{{1}}, PermuParts[[ipreodr]]];
              LenLays = Length[iLayers];
              
              tabLenLays = 
                Join[{1}, Table[Length[iLayers[[i]]], {i, 2, LenLays}]   ];
              
              If[(Pech11), 
                Print[tabLenLays , "=tabLenLays, iLayers=", 
                  MatrixForm[iLayers ]]];
              APreodTrrivs = {};
              
              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}];
              
              For[i = 2, i <= LenLays, i++, (
                  allBelow = Table[iLayers[[ik]], {ik, i - 1}];
                  TargetsBelow = DeleteCases[Subsets[Flatten[allBelow]], {}];
                  TargsCleanBelow = {};
                  LenTarBel = Length[TargetsBelow]; 
                  LeLayPrev = tabLenLays[[i - 1]];
                  If[(Pech11), Print["TargetsBelow=", TargetsBelow]];
                  
                  
                  For[it = 1, it <= LenTarBel, 
                    it++, ( (*Let us check group TargetsBelow[[it]] for \
having a member from previous layer, 
                        to exclude repetitions of same graphs in different \
Preorders :*) For[j = 1, j <= LeLayPrev, j++,
                        (*?? ?*)
                          If[(MemberQ[TargetsBelow[[it]], 
                                iLayers[[i - 1, j]] ]), 
                            TargsCleanBelow = Join[TargsCleanBelow,
                                  {TargetsBelow[[it]]}];];])];
                  
                  LeLay = tabLenLays[[i]];
                  For[j = 1, j <= LeLay, j++, (
                      jthAbsNo = Sum[tabLenLays[[il]], {il, i - 1}] + j;
                      ListAllTargsBel[[jthAbsNo]] = TargsCleanBelow;
                      If[(Pech11), 
                        Print[jthAbsNo, "=jthAbsNo, hisName=iLayers[[i,j]]=(",
                             iLayers[[i, j]], "), TargetsBelow=", 
                            TargetsBelow, ", TargsCleanBelow=", 
                            TargsCleanBelow];];
                      (* prisvoili ...*)
                      LenVersBel = Length[TargsCleanBelow];
                      
                      LisLenAllVersBel[[jthAbsNo]] = 
                        LenVersBel;(*Append[LisLenAllVersBel[[jthAbsNo]], 
                            LenVersBel];*) itr = itr + 1(*= jthAbsNo??*);
                       DeleteCases[ListAllTargsBel[[jthAbsNo]], {}];)];
                  )]; DeleteCases[ListAllTargsBel, {}];
              If[(Pech), Print["\!\(\*
StyleBox[\"accomplished\",\nFontColor->RGBColor[0, 1, 0]]\)  "]; Print["new ListAllTargsBel=", ListAllTargsBel];];
              If[(Pech), Print["and LisLenAllVersBel=", LisLenAllVersBel];];
              manyVers = Product[LisLenAllVersBel[[i]], {i, 2, n + 1}];
              If[(Pech), Print["and manyVers=", manyVers];];
              (* 
                accomplished preparations for building a river or several for \
this Preorder.Vector of lists ListAllTargsBel = 
                  List - of - 
                    targets below each Father (similar within Layer).Target \
is a group of sons possible for Father No jthAbsNo.
                        
                        Each father can select a target.All combinations of \
selections amount to all rivers born by this Preorder. *)
              
              Label[startipreodr];(*start a permuttry*)
              If[(Pech22), Print[try, "=\!\(\*
StyleBox[\"try\",\nFontColor->RGBColor[1, 0, 0]]\) of manyVers=", manyVers, ", current IndxVersn=", IndxVersn];];
              (*how many tries should we make for this ipreodr making trees*)
\

              (* ...*) 
              
              If[(Pech), 
                Print[try , "=try, iLayers=", MatrixForm[iLayers ]]];
              rivTree = {};
              For[i = 2, i <= LenLays, i++, (
                  LeLayPrev = Length[iLayers[[i - 1]]]; 
                  (* ..*)
                  
                  TargetsBelow = 
                    ListAllTargsBel[[i]];(*DeleteCases[
                        Subsets[Flatten[allBelow]], {}];*)
                  LenVersBel = Length[TargetsBelow]; 
                  
                  LeLay = Length[iLayers[[i]]];
                  (*start making arcs for all Fathers of Layer - i*)(
                    For[j = 1, j <= LeLay, j++, (
                        (*.. group of sons *)
                        
                        
                        jthAbsNo = 
                          Sum[tabLenLays[[il]], {il, i - 1}] + j;(*= 
                            Father - j - th absolute - number*)
                        
                        CurTargBelow = 
                          ListAllTargsBel[[jthAbsNo, 
                              IndxVersn[[jthAbsNo]] ]];(*= 
                            current group of sons for this Father *)
                        
                        If[(Pech22), 
                          Print[TargetsBelow, "=TargetsBelow, CurTargBelow=", 
                            CurTargBelow]];
                        (* = 
                            I try to make a .. list of arcs below possible \
for rivers for this FatherJ.  *)
                        LenRaBel = Length[CurTargBelow];
                        For[json = 1, json <= LenRaBel, json++, 
                          imyaSon = CurTargBelow[[json]];
                          
                          rivTree = 
                            Join[rivTree, {{iLayers[[i, j]], (*= 
                                      father's label in new arc*)
                                  
                                  imyaSon (*= 
                                      son's label in new arc.*)      }}]   \
])]) ;
                  )];
              AdjMat = NulMat;
              
              LerivTree = 
                Length[rivTree];(*start making an Adjacency - 
                  Matrix from Tree*)
              For[i = 1, i <= 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["previous AllAdMatrs[[curLenAlAdMat]]=", 
                    MatrixForm[AllAdMatrs[[curLenAlAdMat]]], ", new AdjMat= ",
                     MatrixForm[AdjMat]];]; 
              If[(MemberQ[AllAdMatrs, AdjMat]), If[(Pech11), (Print[ "==Yes-\!\(\*
StyleBox[\"new\",\nFontColor->RGBColor[1, 0, 0]]\)\!\(\*
StyleBox[\"-\",\nFontColor->RGBColor[1, 0, 0]]\)\!\(\*
StyleBox[\"AdjMat\",\nFontColor->RGBColor[1, 0, 0]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[1, 0, 0]]\)\!\(\*
StyleBox[\"is\",\nFontColor->RGBColor[1, 0, 0]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[1, 0, 0]]\)\!\(\*
StyleBox[\"Old\",\nFontColor->RGBColor[1, 0, 0]]\). It is among previouss." ]; 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 of rivers with a new 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}];
              DLx = Table[0, {i, n}];
              T = {t1, t2, t3};
              Equations = {};
              Constr = {};
              solXTreal = {};
              LamNeNul = {};
              PribReal = {};
              Prib1 = {};
              Constraints1 = {};
              LamSuc = Table[0, {i, n}];
              LamPre = Table[0, {i, n}];
              LamPreVprim = Table[0, {i, n}];
              Msum = Table[Mm[[i]], {i, n}];
              Pribil = 0;
              Rivergood = True;
              
              (*------------------------------------------------------------------------*)
\

              
              
              If[(Sum[AdjMat[[i, j]], {i, 2, n + 1}, {j, 1, n + 1}] == 
                    Sum[p, {p, 2, n + 1}]), 
                If[(Pech33), Print["GRAF-DEREVO"]];
                
                For[j0 = 1, j0 <= n, j0++, (
                    
                    j = n + 2 - j0;(*= cs of adjacency matrix, 
                      to find full weights :*) 
                    For[i = 2, i <= n + 1, i++,
                      
                      If[(AdjMat[[i, j]] !=  
                              0), (Msum[[j - 1]] = 
                                Msum[[j - 1]] + Msum[[(AdjMat[[i, j]] - 1)]];
                            )];
                      ];
                    )];
                
                Prof = Sum[Votx[[j, j]]*Mm[[j]], {j, 1, n}];
                For[j0 = 1, j0 <= n, j0++, (
                    j = n + 2 - j0;(*= raws of adjacency matrix, 
                      to find full weights :*) 
                    For[i = 2, i <= n + 1, i++,
                      
                      If[(AdjMat[[i, j]] !=  0), (Prof = 
                              Prof + (Votx[[j - 1, j - 1]] - 
                                      ReplaceAll[
                                        Votx[[i - 1, 
                                        i - 1]], {Xstart[[i - 1]] -> 
                                        Xstart[[j - 1]]}])*Msum[[(i - 1)]])];
                      ];
                    )];
                If[(Pech33), Print["Prof=", Prof]];
                
                solX = Solve[{D[Prof, x1] == 0, D[Prof, x2] == 0, 
                      D[Prof, x3] == 0}, Xstart];
                If[(Pech33), Print[ "solX=", solX   ]];
                
                
                listOfReadyT = {};
For[is = 2, is <= n + 1, 
                  is++, (If[(AdjMat[[is, 1]] != 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 <= n, nprosmotra++, 
                  For[j = 2, j <= n + 1, 
                      j++, (For[i = 2, i <= n + 1, 
                            i++, (If[((AdjMat[[i, j]] != 0) && (MemberQ[
                                        listOfReadyT, j]) && (! 
                                        MemberQ[listOfReadyT, i])), 
                                  T[[i - 1]] = 
                                    T[[j - 1]] - 
                                      ReplaceAll[Votx[[i - 1, i - 1]], 
                                        Xstart[[i - 1]] -> Xstart[[j - 1]]] + 
                                      Votx[[i - 1, i - 1]];
                                  
                                  listOfReadyT = 
                                    Append[listOfReadyT, i];];)];)];];
If[(Pech33), Print["listOfReadyT=", listOfReadyT, ", T=", T]];
                
                
                
                TTn = Chop[T /. solX[[1]]];
                XXn = Chop[Xstart /. solX[[1]]];
                
                If[(Pech33), 
                  Print[{T, Xstart}, "=T,Xstart, po derevu TTn= ", TTn, 
                    ", XXn= ", XXn]];
                
                
                Constraints1 = Constraints;
                For[i = 1, i <= n, i++, (
                    (*Constraints1 = 
                          Constraints1 //. {T2T[[i]] -> TTn[[i]], 
                              Xstart[[i]] -> XXn[[i]]};*)
                    Constraints1 = Constraints1 /. T2T[[i]] -> T[[i]];
                    Chop[Constraints1];
                    )];
                
                (*Print["Constraints:", Constraints1];*)
                Constraints1 = Constraints1 /. solX[[1]];
                (*Print["Constraints:", Constraints1];*)
                
                estresh = True;
                
                For[i = 1, i <=  Length[Constraints1], i++, 
                  If[(Constraints1[[i]] == False), 
                    estresh = False;
                    ]];
                
                Pribil = Prof /. solX ;
                If[(Pech33), Print[estresh, "=\!\(\*
StyleBox[\"estresh\",\nFontColor->RGBColor[0, 1, 0]]\)\!\(\*
StyleBox[\"??\",\nFontColor->RGBColor[0, 1, 0]]\), Pribil= ", Pribil, ", Uopt=", Uopt]];
                If[(NaivPrib <= Pribil[[1]]), (
                    If[(Pribil[[1]] > Uopt), (
                        If[(estresh), ( 
                            Uopt = Pribil[[1]];
                            Xopt = {XXn, TTn};
                            OptMat = AdjMat; If[(Pech33), ( Print["\!\(\*
StyleBox[\"estresh\",\nFontColor->RGBColor[0, 1, 0]]\)\!\(\*
StyleBox[\",\",\nFontColor->RGBColor[0, 1, 0]]\)\!\(\*
StyleBox[\"new\",\nFontColor->RGBColor[1, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[1, 0, 1]]\)\!\(\*
StyleBox[\"Uopt\",\nFontColor->RGBColor[1, 0, 1]]\)\!\(\*
StyleBox[\"!\",\nFontColor->RGBColor[1, 0, 1]]\)"];
                                Print["\!\(\*
StyleBox[\"BADTREES\",\nFontColor->RGBColor[0, 1, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 1, 1]]\)\!\(\*
StyleBox[\"+\",\nFontColor->RGBColor[0, 1, 1]]\)", MatrixForm[AdjMat]];)]),  (*else*)If[(Pech33), 
                            Print["RESHENIY NET!"]]];), 
                      ( (*else lowprofit :*)   
                        BadTrees = Append[BadTrees, AdjMat];
                        lenBadTrees = Length[BadTrees];
                        )]), ( BadTrees = Append[BadTrees, AdjMat];
                    lenBadTrees = Length[BadTrees];)];
                
                
                
                (*--------------------------------------------------------------------------*)
\

                ,
                 If[(Pech33), Print["GRAF-REKA"]];
                
                Rivergood = True;
                
                For[i = 1, i <= Length[BadTrees], i++, 
                  If[(Min[AdjMat - BadTrees[[i]]] >= 0),
                     Rivergood = False; Nskipped = Nskipped + 1;]];
                
                If[(Rivergood), (
                    
                    For[i = 1, i <= Length[BadRivers], i++, 
                      If[(Min[AdjMat - BadRivers[[i]]] >= 0), 
                        Rivergood = False; Nskipped = Nskipped + 1;]];
                    
                    If[(Rivergood), (
                        For[j0 = 1, j0 <= n, j0++, (
                            
                            j = n + 2 - j0;(*= cs of adjacency matrix, 
                              to find full weights :*) 
                            For[i = 2, i <= n + 1, i++,
                              If[(AdjMat[[i, j]] !=  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]] == 0)];)];
                              ];
                            )];
                        
                        
                        For[i = 2, i <= n + 1, 
                          i++,(*= making diagonal elements lambda :*)
                          If[(AdjMat[[i, 1]] !=  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]] == 0)];)];];
                        
                        
                        
                        For[i = 2, i <= n + 1, 
                          i++, ( (*= 
                                making Lambda Successors and predecessors :*)
\

                            (*= raws of adjacency matrix, 
                              to find lambda weights :*) 
                            For[ j = 1, j <= n + 1, j++, 
                              
                              If[(AdjMat[[i, j]] !=  
                                    0 ), (LamSuc[[i - 1]] = LamSuc[[i - 1]] +
                                        
                                        If[(j !=  1 ), (ToExpression[
                                        Lamb[[i - 1, j - 1]]]), (0)];
                                   )];
                              
                              
                              If[(AdjMat[[j, i]] !=  
                                    0 ), (LamPre[[i - 1]] = LamPre[[i - 1]] +
                                        
                                        If[(j !=  1 ), (ToExpression[
                                        Lamb[[j - 1, i - 1]]]), (0)]; 
                                    
                                    LamPreVprim[[i - 1]] = 
                                      LamPreVprim[[i - 1]] +
                                        
                                        If[(j !=  
                                        1 ), (ToExpression[
                                        Lamb[[j - 1, i - 1]]]*
                                        D[ReplaceAll[Votx[[j - 1, j - 1]], 
                                        Xstart[[j - 1]] -> Xstart[[i - 1]]],
                                         Xstart[[i - 1]]]), (0)]);
                                ];
                              ];
                            
                            DLt[[i - 1]] = 
                              Mm[[i - 1]] - LamSuc[[i - 1]] + 
                                LamPre[[i - 1]];
                                DLx[[i - 1]] = D[Votx[[i - 1, i - 1]],
                                    Xstart[[i - 1]]]*LamSuc[[i - 1]] - 
                                LamPreVprim[[i - 1]];
                            Equations = Append[Equations, DLt[[i - 1]] == 0]; 
                            Equations = Append[Equations, DLx[[i - 1]] == 0];
                            ;)
                          ];
                         Equations = Join[Equations, Constr];
                        XT = Join[Xstart, T, LamNeNul];
                        solXTlam = Solve[Equations, XT];
                        solXT = {Xstart, T, LamNeNul} /. solXTlam;
                        lenLamNeNul = Length[LamNeNul];
                        nulLen = Table[0, {i, lenLamNeNul}];
                        
                        
                        solXTmax = {};
                        (* Kornebybiralka : ind = 1 means good. *)
                        For [i = 1, i <= Length[solXT], i++,
                          ind = 1; 
                          
                          
                          For[j = 1, j <= n, j++,
                            
                            If[(Head[solXT[[i, 1, j]]] == Complex), 
                                ind = 0 ];
                            ; ];
                          
                          If[(ind == 1), (
                              Nerav = {};
                              solXTmax = Join[solXTmax, {solXT[[i]]}];
                              For[j = 1, j <= lenLamNeNul, j++, 
                                
                                Nerav = 
                                  Join[Nerav, {solXT[[i, 3, j]] >= 0}]];
                              (*Print["Nerav=", Nerav];*)
                              MinX = Min[solXT[[i, 1]]]; 
                              MinT = Min[solXT[[i, 2]]];
                              priznakLambd = Reduce[Nerav, LamNeNul];
                              For[j = 1, j <= n, j++,
                                
                                If[(MinX < 0) || (MinT < 
                                        0) || (priznakLambd == False) , 
                                    ind = 0 ];
                                ; ];)];
                          
                          If[(ind == 1), 
                            solXTreal = Join[solXTreal, {solXT[[i]]}];];
                          ];
                        
                        If[(solXTreal != {}),
                          For[i = 1, i <= Length[solXTreal], i++, (
                                Constraints1 = Constraints;
                                 
                                For[j = 1, j <= n, j++, 
                                  Constraints1 = 
                                    Constraints1 //. {Xstart[[j]] -> 
                                        solXTreal[[i, 1, j]], 
                                        T2T[[j]] -> solXTreal[[i, 2, j]]};
                                  Chop[Constraints1];
                                  
                                  If[(Pech33), 
                                    Print["Constraints1=", Constraints1]];];
                                solutGood = True;
                                For[k = 1, k <= Length[Constraints1], k++,
                                  solutGood = solutGood && Constraints1[[k]];
                                  ];
                                If[! solutGood, solXTreal[[i]] = {}];
                                )];];
                        
                        If[solXTreal == {{}}, solXTreal = {}];
                        If[solXTreal == {{}, {}}, solXTreal = {}];
                        (*If[solXTmax == {{}}, solXTmax = {}];
                          If[solXTmax == {{}, {}}, solXTmax = {}];*)
                        
                        
                        PribMax = {};
                        For[i = 1, i <= Length[solXTmax], i++, (
                            If[(solXTmax[[i]] != {}),
                               
                              PribMax = 
                                  Append[PribMax, 
                                    Sum[Mm[[j]]*solXTmax[[i, 2, j]], {j, 1, 
                                        n} ]];,
                              (*else*)Append[PribMax, -100]; ])];
                        
                        If[(Pech11), Print["solXT=", solXTlam];
Print["solXTreal=", solXTreal];];
                        
                        If[(Pech11), 
                          Print[ "Lamb=", MatrixForm[Lamb], ", Equations=", 
                              Equations, ", LamNeNul=", LamNeNul];];
                        
                        
                        
                        If[(Pech33), 
                          Print[ "reka if not for constraints PribMax= ", 
                            PribMax, ", Uopt=", Uopt]];
                        
                        If[(solXTreal != {}) , ( (*formuem vector pribylei iz \
vectora kornei systemy :*)
                            For[i = 1, i <= Length[solXTreal], i++, (
                                If[(solXTreal[[i]] != {}),
                                   
                                  PribReal = 
                                      Append[PribReal, 
                                        Sum[Mm[[j]]*solXTreal[[i, 2, j]], {j, 
                                        1, n} ]];,
                                  (*else*)Append[PribReal, -100]; ])];
                            
                            lenPrib = Length[PribReal];
                            iBest = Ordering[PribReal][[lenPrib]];
                            Bestsol = solXTreal[[iBest]];
                            
                            If[(Pech33), 
                              Print["Nailuchaya pribil: ", PribReal[[iBest]], 
                                " Dostigaetsa na reshenii:", 
                                solXTreal[[iBest]]]];
                            
                            If[PribReal[[iBest]] > 
                                Uopt, (Uopt = PribReal[[iBest]];
                                OptMat = AdjMat;
                                Xopt = solXTreal[[iBest]];
                                If[(Pech33), Print["\!\(\*
StyleBox[\"New\",\nFontColor->RGBColor[0, 1, 0]]\) Uopt=", Uopt]])];),
                          (*else*)   If[(Pech33), Print["RESHENIY NET!"]]];
                        
                        If[(Max[PribMax] < Uopt), (
                            BadRivers = Append[BadRivers, AdjMat];
                            lenBadRivers = Length[BadRivers];)];
                        
                        )];
                    )]];
              
              (*---------------------------------------------------------------------------\
*)
              
              
              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 <= n, i++, 
                If[(IndxVersn[[i]] + 1 <= LisLenAllVersBel[[i]]), 
                    IndxVersn[[i]] = IndxVersn[[i]] + 1; Goto[outi],(*else*)
                    
                    If[(IndxVersn[[i + 1]] + 1 <= 
                            LisLenAllVersBel[[i + 1]]), (IndxVersn[[i + 1]] = 
                            IndxVersn[[i + 1]] + 1;
                          For[k = 2, k <= i, k++, IndxVersn[[k]] = 1]; 
                          Goto[outi];)];];]; Label[outi];
              try = try + 1;
              
              If[(try <= manyVers)(*= index - or - permutiterator*), (Goto[
                    startipreodr])];
              LenPreodRvrs = Length[APreodTrrivs];
              
              If[(Pech11), 
                Print[nsymmetrii, "=nsymmetrii,  APreodTrrivs=", APreodTrrivs,
                   ", LenPreodRvrs=", LenPreodRvrs]];
              
              (* 
                Print["  AllAdMatrs=", AllAdMatrs, " , LenMaTrs=", 
                    Length[AllAdMatrs]];*) )]; 
          
          
          If[(Pech11), 
            Print["=******=ku-ku=******,nAllsymmetrii=", nAllsymmetrii]];
          LenAlTrvrs = Length[AllTrrivs];
          (*Print["  AllTrrivs=", AllTrrivs, ", LenAlTrvrs=", LenAlTrvrs];
            
            Print["  AllAdMatrs=", AllAdMatrs, " , LenMaTrs=", 
              Length[AllAdMatrs]];*)
          If[(Pech33), (Print["Nskipped=", Nskipped];
              Print["Uopt= ", Uopt, ", Xopt= ", Xopt];
              Print[ "  OptMat=", MatrixForm[OptMat ]];)];
          
          
          
          If[(Pech33), (
              xx1 = Xopt[[1, 1]]; xx2 = Xopt[[1, 2]]; xx3 = Xopt[[1, 3]];
              {xx1, xx2, xx3} = Xopt[[1]];
              {tt1, tt2, tt3} = Xopt[[2]];
              tt1 = Xopt[[2, 1]]; tt2 = Xopt[[2, 2]]; tt3 = Xopt[[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[{Point[{xx1, tt1}], Point[{xx2, tt2}], 
                    Point[{xx3, tt3}]}];
              
              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}, DisplayFunction -> Identity], 
                  points}, DisplayFunction -> $DisplayFunction];
              
              
              pointsPlan = 
                Graphics[{Point[planTransp[[1]]], Point[planTransp[[2]]], 
                    Point[planTransp[[3]]]}];
              
              Show[{Plot[{Vyp[[1, 3]], Vyp[[2, 3]], Vyp[[3, 3]]}, {x, 0, 
                      xpeakMax*1.5}, PlotStyle -> {Red, Green, Blue}, 
                    PlotRange -> {0, heightMax*1.2}, 
                    DisplayFunction -> Identity], pointsPlan}, 
                DisplayFunction -> $DisplayFunction];
              Print["Plan=", Plan];
              Print["Uopt= ", Uopt, " NaivPrib=", NaivPrib];
              
              Print["Raznica sostavlyaet:  ", 100 - 100*NaivPrib/Uopt, 
                "%"];)];
          If[Uopt != -100, ( Raznobsh = Raznobsh + 100 - 100*NaivPrib/Uopt;
              Nobshskipped = Nobshskipped + Nskipped;
              If[(Min[OptMat - AdjNaiv] >= 0), Npopali = Npopali + 1];
              ), (Nex = Nex - 1)];
          
          )];)];
  
  Nsred = Nobshskipped/NN;
  Print["Nsred=", Nsred]; 
  Print["Srednee otlichie ot naivnogo resheniya sostavlyaet:", Raznobsh/NN, 
    "%"];
  Print["V ", NN, " ispitaniyah popali ", Npopali, " raz"];
  Print["==========finish========="]; EndPackage;
*)
(*
Nex=\[InvisibleSpace]1
*)
(*
\!\(\*
  InterpretationBox[
    RowBox[{"\<\"Votx=\"\>", "\[InvisibleSpace]", 
      TagBox[
        RowBox[{"(", "\[NoBreak]", GridBox[{
              {\(0.6987545358462969`\ x1 - 0.8064439689950386`\ x1\^2\), \(0.6987545358462969`\ x1 - 0.8064439689950386`\ x1\^2 - 0.6987545358462969`\ x2 + 0.8064439689950386`\ x2\^2\), \(0.6987545358462969`\ x1 - 0.8064439689950386`\ x1\^2 - 0.6987545358462969`\ x3 + 0.8064439689950386`\ x3\^2\)},
              {\(\(-1.077311970392747`\)\ x1 + 0.1364328055450272`\ x1\^2 + 1.077311970392747`\ x2 - 0.1364328055450272`\ x2\^2\), \(1.077311970392747`\ x2 - 0.1364328055450272`\ x2\^2\), \(1.077311970392747`\ x2 - 0.1364328055450272`\ x2\^2 - 1.077311970392747`\ x3 + 0.1364328055450272`\ x3\^2\)},
              {\(\(-0.7220141693998454`\)\ x1 + 0.20186787993121075`\ x1\^2 + 0.7220141693998454`\ x3 - 0.20186787993121075`\ x3\^2\), \(\(-0.7220141693998454`\)\ x2 + 0.20186787993121075`\ x2\^2 + 0.7220141693998454`\ x3 - 0.20186787993121075`\ x3\^2\), \(0.7220141693998454`\ x3 - 0.20186787993121075`\ x3\^2\)}
              },
            RowSpacings->1,
            ColumnSpacings->1,
            ColumnAlignments->{Left}], "\[NoBreak]", ")"}],
        Function[ BoxForm`e$, 
          MatrixForm[ BoxForm`e$]]]}],
    SequenceForm[ "Votx=", 
      MatrixForm[ {{
        Plus[ 
          Times[ .69875453584629688, x1], 
          Times[ -.80644396899503856, 
            Power[ x1, 2]]], 
        Plus[ 
          Times[ .69875453584629688, x1], 
          Times[ -.80644396899503856, 
            Power[ x1, 2]], 
          Times[ -.69875453584629688, x2], 
          Times[ .80644396899503856, 
            Power[ x2, 2]]], 
        Plus[ 
          Times[ .69875453584629688, x1], 
          Times[ -.80644396899503856, 
            Power[ x1, 2]], 
          Times[ -.69875453584629688, x3], 
          Times[ .80644396899503856, 
            Power[ x3, 2]]]}, {
        Plus[ 
          Times[ -1.077311970392747, x1], 
          Times[ .13643280554502721, 
            Power[ x1, 2]], 
          Times[ 1.077311970392747, x2], 
          Times[ -.13643280554502721, 
            Power[ x2, 2]]], 
        Plus[ 
          Times[ 1.077311970392747, x2], 
          Times[ -.13643280554502721, 
            Power[ x2, 2]]], 
        Plus[ 
          Times[ 1.077311970392747, x2], 
          Times[ -.13643280554502721, 
            Power[ x2, 2]], 
          Times[ -1.077311970392747, x3], 
          Times[ .13643280554502721, 
            Power[ x3, 2]]]}, {
        Plus[ 
          Times[ -.72201416939984542, x1], 
          Times[ .20186787993121075, 
            Power[ x1, 2]], 
          Times[ .72201416939984542, x3], 
          Times[ -.20186787993121075, 
            Power[ x3, 2]]], 
        Plus[ 
          Times[ -.72201416939984542, x2], 
          Times[ .20186787993121075, 
            Power[ x2, 2]], 
          Times[ .72201416939984542, x3], 
          Times[ -.20186787993121075, 
            Power[ x3, 2]]], 
        Plus[ 
          Times[ .72201416939984542, x3], 
          Times[ -.20186787993121075, 
            Power[ x3, 2]]]}}]],
    Editable->False]\)
*)
(*
\!\(\*
  InterpretationBox[
    RowBox[{"\<\"\\!\\(\\* StyleBox[\\\"VmatrotX\\\",\\nFontColor->RGBColor[0, 0, 1]]\\)[Vv,#1 ,n]=\"\>", "\[InvisibleSpace]", \({{0.6987545358462969`\ x1 - 0.8064439689950386`\ x1\^2, 0.6987545358462969`\ x1 - 0.8064439689950386`\ x1\^2 - 0.6987545358462969`\ x2 + 0.8064439689950386`\ x2\^2, 0.6987545358462969`\ x1 - 0.8064439689950386`\ x1\^2 - 0.6987545358462969`\ x3 + 0.8064439689950386`\ x3\^2}, {\(-1.077311970392747`\)\ x1 + 0.1364328055450272`\ x1\^2 + 1.077311970392747`\ x2 - 0.1364328055450272`\ x2\^2, 1.077311970392747`\ x2 - 0.1364328055450272`\ x2\^2, 1.077311970392747`\ x2 - 0.1364328055450272`\ x2\^2 - 1.077311970392747`\ x3 + 0.1364328055450272`\ x3\^2}, {\(-0.7220141693998454`\)\ x1 + 0.20186787993121075`\ x1\^2 + 0.7220141693998454`\ x3 - 0.20186787993121075`\ x3\^2, \(-0.7220141693998454`\)\ x2 + 0.20186787993121075`\ x2\^2 + 0.7220141693998454`\ x3 - 0.20186787993121075`\ x3\^2, 0.7220141693998454`\ x3 - 0.20186787993121075`\ x3\^2}}\)}],
    SequenceForm[ "\!\(\* StyleBox[\"VmatrotX\",\nFontColor->RGBColor[0, 0, 1]]\)[Vv,#1 ,n]=", {{
      Plus[ 
        Times[ .69875453584629688, x1], 
        Times[ -.80644396899503856, 
          Power[ x1, 2]]], 
      Plus[ 
        Times[ .69875453584629688, x1], 
        Times[ -.80644396899503856, 
          Power[ x1, 2]], 
        Times[ -.69875453584629688, x2], 
        Times[ .80644396899503856, 
          Power[ x2, 2]]], 
      Plus[ 
        Times[ .69875453584629688, x1], 
        Times[ -.80644396899503856, 
          Power[ x1, 2]], 
        Times[ -.69875453584629688, x3], 
        Times[ .80644396899503856, 
          Power[ x3, 2]]]}, {
      Plus[ 
        Times[ -1.077311970392747, x1], 
        Times[ .13643280554502721, 
          Power[ x1, 2]], 
        Times[ 1.077311970392747, x2], 
        Times[ -.13643280554502721, 
          Power[ x2, 2]]], 
      Plus[ 
        Times[ 1.077311970392747, x2], 
        Times[ -.13643280554502721, 
          Power[ x2, 2]]], 
      Plus[ 
        Times[ 1.077311970392747, x2], 
        Times[ -.13643280554502721, 
          Power[ x2, 2]], 
        Times[ -1.077311970392747, x3], 
        Times[ .13643280554502721, 
          Power[ x3, 2]]]}, {
      Plus[ 
        Times[ -.72201416939984542, x1], 
        Times[ .20186787993121075, 
          Power[ x1, 2]], 
        Times[ .72201416939984542, x3], 
        Times[ -.20186787993121075, 
          Power[ x3, 2]]], 
      Plus[ 
        Times[ -.72201416939984542, x2], 
        Times[ .20186787993121075, 
          Power[ x2, 2]], 
        Times[ .72201416939984542, x3], 
        Times[ -.20186787993121075, 
          Power[ x3, 2]]], 
      Plus[ 
        Times[ .72201416939984542, x3], 
        Times[ -.20186787993121075, 
          Power[ x3, 2]]]}}],
    Editable->False]\)
*)
(*
\!\(\*
  RowBox[{\(Solve::"svars"\), \(\(:\)\(\ \)\), "\<\"Equations may not give solutions for all \\\"solve\\\" variables. \\!\\(\\*ButtonBox[\\\"More\[Ellipsis]\\\", ButtonStyle->\\\"RefGuideLinkText\\\", ButtonFrame->None, ButtonData:>\\\"Solve::svars\\\"]\\)\"\>"}]\)
*)
(*
\!\(\*
  RowBox[{\(Reduce::"ratnz"\), \(\(:\)\(\ \)\), "\<\"Reduce was unable to solve the system with inexact coefficients. The answer was obtained by solving a corresponding exact system and numericizing the result. \\!\\(\\*ButtonBox[\\\"More\[Ellipsis]\\\", ButtonStyle->\\\"RefGuideLinkText\\\", ButtonFrame->None, ButtonData:>\\\"Reduce::ratnz\\\"]\\)\"\>"}]\)
*)
(*
\!\(\*
  RowBox[{\(Solve::"svars"\), \(\(:\)\(\ \)\), "\<\"Equations may not give solutions for all \\\"solve\\\" variables. \\!\\(\\*ButtonBox[\\\"More\[Ellipsis]\\\", ButtonStyle->\\\"RefGuideLinkText\\\", ButtonFrame->None, ButtonData:>\\\"Solve::svars\\\"]\\)\"\>"}]\)
*)
(*
\!\(\*
  RowBox[{\(Reduce::"ratnz"\), \(\(:\)\(\ \)\), "\<\"Reduce was unable to solve the system with inexact coefficients. The answer was obtained by solving a corresponding exact system and numericizing the result. \\!\\(\\*ButtonBox[\\\"More\[Ellipsis]\\\", ButtonStyle->\\\"RefGuideLinkText\\\", ButtonFrame->None, ButtonData:>\\\"Reduce::ratnz\\\"]\\)\"\>"}]\)
*)
(*
\!\(\*
  RowBox[{\(Solve::"svars"\), \(\(:\)\(\ \)\), "\<\"Equations may not give solutions for all \\\"solve\\\" variables. \\!\\(\\*ButtonBox[\\\"More\[Ellipsis]\\\", ButtonStyle->\\\"RefGuideLinkText\\\", ButtonFrame->None, ButtonData:>\\\"Solve::svars\\\"]\\)\"\>"}]\)
*)
(*
\!\(\*
  RowBox[{\(General::"stop"\), \(\(:\)\(\ \)\), "\<\"Further output of \\!\\(Solve :: \\\"svars\\\"\\) will be suppressed during this calculation. \\!\\(\\*ButtonBox[\\\"More\[Ellipsis]\\\", ButtonStyle->\\\"RefGuideLinkText\\\", ButtonFrame->None, ButtonData:>\\\"General::stop\\\"]\\)\"\>"}]\)
*)
(*
\!\(\*
  RowBox[{\(Reduce::"ratnz"\), \(\(:\)\(\ \)\), "\<\"Reduce was unable to solve the system with inexact coefficients. The answer was obtained by solving a corresponding exact system and numericizing the result. \\!\\(\\*ButtonBox[\\\"More\[Ellipsis]\\\", ButtonStyle->\\\"RefGuideLinkText\\\", ButtonFrame->None, ButtonData:>\\\"Reduce::ratnz\\\"]\\)\"\>"}]\)
*)
(*
\!\(\*
  RowBox[{\(General::"stop"\), \(\(:\)\(\ \)\), "\<\"Further output of \\!\\(Reduce :: \\\"ratnz\\\"\\) will be suppressed during this calculation. \\!\\(\\*ButtonBox[\\\"More\[Ellipsis]\\\", ButtonStyle->\\\"RefGuideLinkText\\\", ButtonFrame->None, ButtonData:>\\\"General::stop\\\"]\\)\"\>"}]\)
*)
(*
Nex=\[InvisibleSpace]2
*)
(*
\!\(\*
  InterpretationBox[
    RowBox[{"\<\"Votx=\"\>", "\[InvisibleSpace]", 
      TagBox[
        RowBox[{"(", "\[NoBreak]", GridBox[{
              {\(1.0067092267019337`\ x1 - 0.3853319919074364`\ x1\^2\), \(1.0067092267019337`\ x1 - 0.3853319919074364`\ x1\^2 - 1.0067092267019337`\ x2 + 0.3853319919074364`\ x2\^2\), \(1.0067092267019337`\ x1 - 0.3853319919074364`\ x1\^2 - 1.0067092267019337`\ x3 + 0.3853319919074364`\ x3\^2\)},
              {\(\(-1.014026817715589`\)\ x1 + 0.8676041655338194`\ x1\^2 + 1.014026817715589`\ x2 - 0.8676041655338194`\ x2\^2\), \(1.014026817715589`\ x2 - 0.8676041655338194`\ x2\^2\), \(1.014026817715589`\ x2 - 0.8676041655338194`\ x2\^2 - 1.014026817715589`\ x3 + 0.8676041655338194`\ x3\^2\)},
              {\(\(-0.8315869584526172`\)\ x1 + 0.37833167634971854`\ x1\^2 + 0.8315869584526172`\ x3 - 0.37833167634971854`\ x3\^2\), \(\(-0.8315869584526172`\)\ x2 + 0.37833167634971854`\ x2\^2 + 0.8315869584526172`\ x3 - 0.37833167634971854`\ x3\^2\), \(0.8315869584526172`\ x3 - 0.37833167634971854`\ x3\^2\)}
              },
            RowSpacings->1,
            ColumnSpacings->1,
            ColumnAlignments->{Left}], "\[NoBreak]", ")"}],
        Function[ BoxForm`e$, 
          MatrixForm[ BoxForm`e$]]]}],
    SequenceForm[ "Votx=", 
      MatrixForm[ {{
        Plus[ 
          Times[ 1.0067092267019337, x1], 
          Times[ -.38533199190743639, 
            Power[ x1, 2]]], 
        Plus[ 
          Times[ 1.0067092267019337, x1], 
          Times[ -.38533199190743639, 
            Power[ x1, 2]], 
          Times[ -1.0067092267019337, x2], 
          Times[ .38533199190743639, 
            Power[ x2, 2]]], 
        Plus[ 
          Times[ 1.0067092267019337, x1], 
          Times[ -.38533199190743639, 
            Power[ x1, 2]], 
          Times[ -1.0067092267019337, x3], 
          Times[ .38533199190743639, 
            Power[ x3, 2]]]}, {
        Plus[ 
          Times[ -1.0140268177155889, x1], 
          Times[ .86760416553381936, 
            Power[ x1, 2]], 
          Times[ 1.0140268177155889, x2], 
          Times[ -.86760416553381936, 
            Power[ x2, 2]]], 
        Plus[ 
          Times[ 1.0140268177155889, x2], 
          Times[ -.86760416553381936, 
            Power[ x2, 2]]], 
        Plus[ 
          Times[ 1.0140268177155889, x2], 
          Times[ -.86760416553381936, 
            Power[ x2, 2]], 
          Times[ -1.0140268177155889, x3], 
          Times[ .86760416553381936, 
            Power[ x3, 2]]]}, {
        Plus[ 
          Times[ -.83158695845261721, x1], 
          Times[ .37833167634971854, 
            Power[ x1, 2]], 
          Times[ .83158695845261721, x3], 
          Times[ -.37833167634971854, 
            Power[ x3, 2]]], 
        Plus[ 
          Times[ -.83158695845261721, x2], 
          Times[ .37833167634971854, 
            Power[ x2, 2]], 
          Times[ .83158695845261721, x3], 
          Times[ -.37833167634971854, 
            Power[ x3, 2]]], 
        Plus[ 
          Times[ .83158695845261721, x3], 
          Times[ -.37833167634971854, 
            Power[ x3, 2]]]}}]],
    Editable->False]\)
*)
(*
\!\(\*
  InterpretationBox[
    RowBox[{"\<\"\\!\\(\\* StyleBox[\\\"VmatrotX\\\",\\nFontColor->RGBColor[0, 0, 1]]\\)[Vv,#1 ,n]=\"\>", "\[InvisibleSpace]", \({{1.0067092267019337`\ x1 - 0.3853319919074364`\ x1\^2, 1.0067092267019337`\ x1 - 0.3853319919074364`\ x1\^2 - 1.0067092267019337`\ x2 + 0.3853319919074364`\ x2\^2, 1.0067092267019337`\ x1 - 0.3853319919074364`\ x1\^2 - 1.0067092267019337`\ x3 + 0.3853319919074364`\ x3\^2}, {\(-1.014026817715589`\)\ x1 + 0.8676041655338194`\ x1\^2 + 1.014026817715589`\ x2 - 0.8676041655338194`\ x2\^2, 1.014026817715589`\ x2 - 0.8676041655338194`\ x2\^2, 1.014026817715589`\ x2 - 0.8676041655338194`\ x2\^2 - 1.014026817715589`\ x3 + 0.8676041655338194`\ x3\^2}, {\(-0.8315869584526172`\)\ x1 + 0.37833167634971854`\ x1\^2 + 0.8315869584526172`\ x3 - 0.37833167634971854`\ x3\^2, \(-0.8315869584526172`\)\ x2 + 0.37833167634971854`\ x2\^2 + 0.8315869584526172`\ x3 - 0.37833167634971854`\ x3\^2, 0.8315869584526172`\ x3 - 0.37833167634971854`\ x3\^2}}\)}],
    SequenceForm[ "\!\(\* StyleBox[\"VmatrotX\",\nFontColor->RGBColor[0, 0, 1]]\)[Vv,#1 ,n]=", {{
      Plus[ 
        Times[ 1.0067092267019337, x1], 
        Times[ -.38533199190743639, 
          Power[ x1, 2]]], 
      Plus[ 
        Times[ 1.0067092267019337, x1], 
        Times[ -.38533199190743639, 
          Power[ x1, 2]], 
        Times[ -1.0067092267019337, x2], 
        Times[ .38533199190743639, 
          Power[ x2, 2]]], 
      Plus[ 
        Times[ 1.0067092267019337, x1], 
        Times[ -.38533199190743639, 
          Power[ x1, 2]], 
        Times[ -1.0067092267019337, x3], 
        Times[ .38533199190743639, 
          Power[ x3, 2]]]}, {
      Plus[ 
        Times[ -1.0140268177155889, x1], 
        Times[ .86760416553381936, 
          Power[ x1, 2]], 
        Times[ 1.0140268177155889, x2], 
        Times[ -.86760416553381936, 
          Power[ x2, 2]]], 
      Plus[ 
        Times[ 1.0140268177155889, x2], 
        Times[ -.86760416553381936, 
          Power[ x2, 2]]], 
      Plus[ 
        Times[ 1.0140268177155889, x2], 
        Times[ -.86760416553381936, 
          Power[ x2, 2]], 
        Times[ -1.0140268177155889, x3], 
        Times[ .86760416553381936, 
          Power[ x3, 2]]]}, {
      Plus[ 
        Times[ -.83158695845261721, x1], 
        Times[ .37833167634971854, 
          Power[ x1, 2]], 
        Times[ .83158695845261721, x3], 
        Times[ -.37833167634971854, 
          Power[ x3, 2]]], 
      Plus[ 
        Times[ -.83158695845261721, x2], 
        Times[ .37833167634971854, 
          Power[ x2, 2]], 
        Times[ .83158695845261721, x3], 
        Times[ -.37833167634971854, 
          Power[ x3, 2]]], 
      Plus[ 
        Times[ .83158695845261721, x3], 
        Times[ -.37833167634971854, 
          Power[ x3, 2]]]}}],
    Editable->False]\)
*)
(*
Nsred=\[InvisibleSpace]50.
*)
(*
Srednee otlichie ot naivnogo resheniya sostavlyaet:\[InvisibleSpace]14.9082\
\[InvisibleSpace]%
*)
(*
V \[InvisibleSpace]2\[InvisibleSpace] ispitaniyah popali \[InvisibleSpace]2\
\[InvisibleSpace] raz
*)
(*
==========finish=========
*)
(*

*)

Online Appendix for "Digraph Algorithm for Screening"

 Файл (PDF, 339 Кб)

 


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

Расписание занятий на сегодня

Полное расписание

Бренд в свободном полете

Сергей Коковин, ведущий научный сотрудник лаборатории теории рынков и пространственной экономики Высшей школы экономики в Санкт-Петербурге: "Легализация так называемого параллельного импорта, безусловно, станет благом для рядового потребителя. Однако вопрос в том, получит ли этот законопроект право на жизнь. У экономистов принято взвешивать выгоды и убытки всех сторон. Инициатива по легализации параллельного импорта не является выгодной всем, она нарушает интересы эксклюзивных дистрибьюторов - крупных компаний, которые имеют сильное лобби".

Российская газета

Импорт признали угрозой национальной безопасности России

Сергей Коковин, ведущий научный сотрудник Лаборатории теории рынков и пространственной экономики Высшей школы экономики в Петербурге, уверен, что проблемы как таковой на самом деле нет:
– 55% нашего импорта составляют станки и оборудование. Это означает, что мы импортируем высокотехнологичную продукцию и обновляем производство вместо того, чтобы замыкаться на себе.

Metro

Почему большие города растут, а маленькие худеют

С 4 по 28 февраля Международная лаборатория теории рынков и пространственной экономики проводит серию международных научных семинаров, ведущий научный сотрудник лаборатории Сергей Коковин рассказывает о том, какие ученые приезжают в Вышку и о чем они будут говорить

Monopolistic Competition: Beyond the CES

Статья сотрудников Лаборатории теории рынков и пространственной экономики ВШЭ «Monopolistic Competition: Beyond the CES» принята к публикации в журнал «Econometrica».

Пространственная экономика

6–7 апреля в рамках XIII Апрельской конференции по проблемам экономики и общества прошла международная научная конференция «Эндогенные рыночные структуры и пространственная экономика».

Симпозиум по теории рынков и пространственной экономике

С 15 по 17 февраля лаборатории ТРПЭ организовала первый симпозиум по теории рынков и пространственной экономике, на котором прошла очередная встреча ее сотрудников с другими исследователями из разных городов России и зарубежья.

Сергей Коковин: Малый бизнес стабилизирует рынок

Ведущий научный сотрудник Международной лаборатории теории рынков и пространственной экономики кандидат физико-математических наук Сергей Коковин рассказывает сначала о монополистической конкуренции, затем о будущем мастер-классе на Зимнем фестивале науки - об экономических моделях политики