• 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 году.
  • Научно-педагогический стаж: 32 года.

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

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

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

  • 1981

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

  • 1981

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

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

Выпускные квалификационные работы студентов

Полный список ВКР

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

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

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

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

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

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

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

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

Публикации29

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

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

Online-Appendix for "Retailer-Leader"

Appendix for: "Russian migration liberalization in 2007-8"

Appendix for: "Russian migration liberalization in 2007-8"

Sergey Onenko1 and Sergey Kokovin

1 National Research University Higher School of Economics, Russia, Saint Petersburg, Griboedov canal 123, research fellow, graduate student, sergeyonenko@mail.ru, +7981-913-7327, . This study has been funded by the Russian Academic Excellence Project ’5-100’. The authors express gratitude for useful comments to Elena Vakulenko, and Olga Lazareva who read the draft and suggested improvements, whereas the remaining shortcomings are our own.

Sergey Onenko1 and Sergey Kokovin

1 National Research University Higher School of Economics, Russia, Saint Petersburg, Griboedov canal 123, research fellow, graduate student, sergeyonenko@mail.ru, +7981-913-7327, . This study has been funded by the Russian Academic Excellence Project ’5-100’. The authors express gratitude for useful comments to Elena Vakulenko, and Olga Lazareva who read the draft and suggested improvements, whereas the remaining shortcomings are our own.


 

Разное

(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

Интервью с Сергеем Коковиным

Cегодня на наши вопросы ответил Сергей Гелиевич Коковин, академический руководитель образовательной программы «Экономика» в НИУ ВШЭ – СПб, преподаватель «Теории игр» в НИУ ВШЭ – Спб и Новосибирском государственном университете. Именно благодаря Сергею Гелиевичу олимпиада будет проходить также и в Новосибирске. Таким образом, первый тур олимпиады будет проходить в 5 городах одновременно: Москва, Санкт-Петербург, Нижний Новгород, Пермь и Новосибирск.

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

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

Monopolistic Competition: Beyond the CES

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

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

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

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

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

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

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