(************** Content-type: application/mathematica **************

                    Mathematica-Compatible Notebook

This notebook can be used with any Mathematica-compatible
application, such as Mathematica, MathReader or Publicon. The data
for the notebook starts with the line containing stars above.

To get the notebook into a Mathematica-compatible application, do
one of the following:

* Save the data starting with the line of stars above into a file
  with a name ending in .nb, then open the file inside the
  application;

* Copy the data starting with the line of stars above to the
  clipboard, then use the Paste menu command inside the application.

Data for notebooks contains only printable 7-bit ASCII and can be
sent directly in email or through ftp in text mode.  Newlines can be
CR, LF or CRLF (Unix, Macintosh or MS-DOS style).

NOTE: If you modify the data for this notebook not in a Mathematica-
compatible application, you must delete the line below containing
the word CacheID, otherwise Mathematica-compatible applications may
try to use invalid cache data.

For more information on notebooks and Mathematica-compatible 
applications, contact Wolfram Research:
  web: http://www.wolfram.com
  email: info@wolfram.com
  phone: +1-217-398-0700 (U.S.)

Notebook reader applications are available free of charge from 
Wolfram Research.
*******************************************************************)

(*CacheID: 232*)


(*NotebookFileLineBreakTest
NotebookFileLineBreakTest*)
(*NotebookOptionsPosition[     66085,       1476]*)
(*NotebookOutlinePosition[     66800,       1501]*)
(*  CellTagsIndexPosition[     66756,       1497]*)
(*WindowFrame->Normal*)



Notebook[{
Cell["\<\
Given a 2-player game of incomplete information (with a payoff function of a \
certain form) and a piecewise-linear strategy (mapping from type to action), \
find a best-response strategy.
TODO: check literature on Cournot adjustment and tatonnement (see p23 of \
Fudenberg&Tirole)\
\>", "Text"],

Cell[CellGroupData[{

Cell["Libraries and Constants", "Section"],

Cell[BoxData[
    \(\(Switch["\<unix\>", \[IndentingNewLine]"\<unix\>", $Path = 
          Join[$Path, {Environment["\<HOME\>"] <> "\</lib/\>", 
              Environment["\<HOME\>"] <> "\</equilibria/\>"}], \
\[IndentingNewLine]"\<windows\>", $Path = 
          Join[$Path, {"\<E:\\lib\\\>", "\<E:\\equilibria\\\>"}], \
\[IndentingNewLine]"\<home\>", $Path = 
          Join[$Path, {"\<C:\\windows\\desktop\\\>"}]];\)\)], "Input"],

Cell[BoxData[
    \(Get["\<Util.m\>"]\)], "Input"],

Cell[CellGroupData[{

Cell["First-price sealed-bid auction example", "Subsection"],

Cell[BoxData[{
    \(s1 = 0; s2 = 1; s3 = \(-1\); s4 = 1; s5 = 1; s6 = \(-1\); 
    s7 = 0;\ \ \), "\[IndentingNewLine]", 
    \(\(minType = 0;\)\), "\[IndentingNewLine]", 
    \(\(maxType = 1;\)\ \), "\[IndentingNewLine]", 
    \(\(minAction = 0;\)\), "\[IndentingNewLine]", 
    \(\(maxAction = 1;\)\)}], "Input"],

Cell[BoxData[
    \( (*\ finds\ the\ equilibrium\ b \((c)\) = \(c/2\ by\ best - 
            response\ iteration\ starting\ from\ b \((c)\) = 
          c\)\ *) \)], "Input"]
}, Open  ]],

Cell[CellGroupData[{

Cell["Supply-chain bargaining game example", "Subsection"],

Cell[BoxData[{
    \(\(v = 1/5*\((10 - 5^\((1/2)\))\);\)\), "\[IndentingNewLine]", 
    \(s1 = 0; s2 = 1; s3 = 1; s4 := v; s5 = \(-1\); s6 = 1; 
    s7 = 0;\ \), "\[IndentingNewLine]", 
    \(\(minType = 0;\)\), "\[IndentingNewLine]", 
    \(\(maxType = 1;\)\ \), "\[IndentingNewLine]", 
    \(\(minAction = 0;\)\), "\[IndentingNewLine]", 
    \(maxAction := v\)}], "Input"]
}, Open  ]],

Cell[CellGroupData[{

Cell["Parameterized payoff function and agent-type distribution", "Subsection"],

Cell[BoxData[
    \( (*\ This\ function\ is\ never\ used, \ 
      but\ this\ is\ the\ form\ that\ it\ is\ assumed\ to\ \(take : \
\[IndentingNewLine]payoff[myType_, myAction_, 
              opponentAction_]\) := \[IndentingNewLine]\ \ \ \ Which[
          s1 \[LessEqual] s2*myAction + s3*opponentAction \[LessEqual] s4, 
          s5*myType + s6*myAction + s7, True, 
          0]\[IndentingNewLine]*) \)], "Input"],

Cell[BoxData[
    \(\(\( (*\ 
      The\ cdf\ of\ the\ common - 
        knowledge\ distribution\ from\ which\ types\ are\ drawn . \ \ \
Currently\ must\ be\ uniform, \ ie, \ 
      CDF\ must\ be\ of\ the\ form\ ax + \(\(b\)\(.\)\)\ *) \)\(\
\[IndentingNewLine]\)\(F[
        type_] := \((type - minType)\)/\((maxType - minType)\)\)\)\)], "Input"]
}, Open  ]]
}, Open  ]],

Cell[CellGroupData[{

Cell["Functions", "Section"],

Cell[CellGroupData[{

Cell["\<\
Converting strategies between functions and their matrix representations\
\>", "Subsection"],

Cell[BoxData[{
    \(\(conditionToRange::usage = "\<Converts a<=x<=b to {a,b}.  Used by \
strategyToMatrix.\>";\)\), "\[IndentingNewLine]", 
    \(\(SetAttributes[conditionToRange, 
        HoldFirst];\)\), "\[IndentingNewLine]", 
    \(conditionToRange[
        left_ <= var_Symbol <= right_] := \((If[
          TrueQ[left > 
              right], \[IndentingNewLine]Print["\<WARNING (conditionToRange): \
possibly invalid range \>", {left, right}]]; \[IndentingNewLine]{left, 
          right})\)\)}], "Input"],

Cell[BoxData[{
    \(\(fToAB::usage = "\<Converts a*x+b to {a,b}.  Used by strategyToMatrix.\
\>";\)\), "\[IndentingNewLine]", 
    \(\(fToAB[var_Symbol]\)[f_] := 
      Module[{l}, \[IndentingNewLine]l = 
          CoefficientList[f, var]; \[IndentingNewLine]If[Length[l] > 2, 
          Print["\<ERROR (fToAB): nonlinear function:\n\>", 
            f]]; \[IndentingNewLine]PadLeft[Reverse[l], 2]]\)}], "Input"],

Cell[BoxData[{
    \(\(strategyToMatrix::usage = "\<Assumes that the strategy is expressed \
with a Which and all the conditions are of the form min\[LessEqual]x\
\[LessEqual]max and all the then-parts are linear in the type.  Each Which \
pair (a<=x<=b, q*x+r) gets turned into a row in the strategy matrix \
({a,b,q,r}).\>";\)\), "\[IndentingNewLine]", 
    \(strategyToMatrix[s_] := 
      Module[{t, ifs, thens}, \[IndentingNewLine]{ifs, thens} = 
          Transpose[
            DeleteCases[
              Partition[s[t] /. Which \[Rule] List, 
                2], {False, _}]]; \[IndentingNewLine]Flatten /@ 
          Transpose[{conditionToRange /@ ifs, 
              fToAB[t] /@ thens}]]\)}], "Input"],

Cell[BoxData[{
    \(\(rangeToCondition::usage = "\<Converts {a,b} to a<=x<=b.  Used by \
matrixToStrategy.\>";\)\), "\[IndentingNewLine]", 
    \(\(rangeToCondition[var_Symbol]\)[{min_, max_}] := 
      min \[LessEqual] var \[LessEqual] max\)}], "Input"],

Cell[BoxData[{
    \(\(abToF::usage = "\<Converts {a,b} to ax+b.  Used by \
matrixToStrategy.\>";\)\), "\[IndentingNewLine]", 
    \(\(abToF[var_Symbol]\)[{a_, b_}] := a*var + b\)}], "Input"],

Cell[BoxData[{
    \(\(matrixToStrategy::usage = "\<Returns a lambda function mapping type \
to action.\>";\)\), "\[IndentingNewLine]", 
    \(matrixToStrategy[m_] := 
      Module[{ifs, thens, type}, \[IndentingNewLine]{ifs, thens} = 
          Transpose[\(Partition[#, 2] &\) /@ m]; \[IndentingNewLine]Function[
          type, Evaluate[
            Which @@ Flatten[
                Transpose[{rangeToCondition[type] /@ ifs, 
                    abToF[type] /@ thens}]]]]]\)}], "Input"]
}, Open  ]],

Cell[BoxData[{
    \(\(pBetw::usage = "\<Uses CDF F (globally defined) to find the \
probability that a random agent type is between a and b.  Used by ep \
(expected payoff).\>";\)\), "\[IndentingNewLine]", 
    \(pBetw[a_, b_] := 
      Max[0, Max[0, Min[1, F[b]]] - Max[0, Min[1, F[a]]]]\)}], "Input"],

Cell[BoxData[
    \(\(\( (*\ 
      Calculation\ for\ \(\(oppTypeBound\)\(.\)\)\ *) \)\(\[IndentingNewLine]\
\)\(Module[{s2, action, s3, m, t, c, 
          bound}, \[IndentingNewLine]\(Solve[
            s2*action + s3*\((m*t + c)\) \[Equal] bound, t]\)[\([1, 1, 
            2]\)]];\)\)\)], "Input"],

Cell[BoxData[{
    \(\(oppTypeBound::usage = "\<Takes my action, a bound (either s1 or s4 \
from the payoff parameterization), and constants m and c from the opponent \
strategy matrix.  Returns the corresponding bound on the opponent's type.  \
Used by ep (expected payoff) and ep candidates.  O(1).\>";\)\), "\
\[IndentingNewLine]", 
    \(oppTypeBound[action_, bound_, m_, 
        c_] := \((bound - action*s2 - c*s3)\)/\((m*s3)\)\)}], "Input"],

Cell[BoxData[{
    \(\(prob::usage = "\<Takes action, a range from the strategy matrix \
(a,b), and coefficients from the strategy matrix (m,c), and returns the \
probability that the opponent's type is in the range [a,b] and that we'll get \
the non-zero payoff with the opponent doing action m*itsType+c.  ({a,b,m,c} \
is one row from the strategy matrix.)  Used by ep.  O(3).\>";\)\), "\
\[IndentingNewLine]", 
    \(\(prob[action_]\)[{a_, b_, m_, c_}] := 
      Which[\[IndentingNewLine]s3*m > 0, 
        pBetw[Max[a, oppTypeBound[action, s1, m, c]], 
          Min[b, oppTypeBound[action, s4, m, c]]], \[IndentingNewLine]s3*m < 
          0, pBetw[Max[a, oppTypeBound[action, s4, m, c]], 
          Min[b, oppTypeBound[action, s1, m, c]]], \[IndentingNewLine]s3*
            m \[Equal] 0, 
        If[s1 \[LessEqual] s2*action + s3*c \[LessEqual] s4, 1, 0]*
          pBetw[a, b]]\)}], "Input"],

Cell[BoxData[{
    \(\(ep::usage = "\<ep gives the expected payoff given my type and action \
and given my oppenent's strategy matrix sm.  Used by neededCandidate and \
bestBRC.  O(3 * num pieces in strategy) = O(3n).\>";\)\), \
"\[IndentingNewLine]", 
    \(ep[type_, action_, sm_] := \((s5*type + s6*action + s7)\)*
        Plus @@ \((prob[action] /@ sm)\)\)}], "Input"],

Cell[BoxData[{
    \(\(f::usage = "\<A convenience function for actionBoundariesSub; what \
you get when you set oppTypeBound equal to x with y as the bound and solve \
for my action.  O(1).\>";\)\), "\[IndentingNewLine]", 
    \(f[a_, b_, m_, c_, x_, y_] := \((y - x*s3*m - s3*c)\)/s2\)}], "Input"],

Cell[BoxData[{
    \( (*\ TODO : \ 
        an\ easier\ way\ to\ get\ these\ would\ be\ to\ set\ all\ the\ \
epCandidates\ equal\ to\ each\ other\ pair - 
          wise\ and\ solve\ for\ \(\(action\)\(.\)\)\ *) \
\[IndentingNewLine]\(actionBoundariesSub::usage = "\<Takes a row from the \
strategy matrix and returns a list of implied critical points based on \
boundary conditions. TODO: eliminate boundaries where the derivative (or \
derivatives of all the candidates) is negative.  TODO: also eliminate \
boundaries  O(12).\>";\)\), "\[IndentingNewLine]", 
    \(actionBoundariesSub[{a_, b_, m_, c_}] := 
      Select[{f[a, b, m, c, a, s1], f[a, b, m, c, b, s1], 
          f[a, b, m, c, a, s4], 
          f[a, b, m, c, b, s4], \((s1 - s3*c)\)/s2, \((s4 - s3*c)\)/s2}, 
        minAction \[LessEqual] # \[LessEqual] maxAction &]\)}], "Input"],

Cell[BoxData[{
    \(\(actionBoundaries::usage = "\<Takes a strategy matrix and returns all \
the critical points based on boundary conditions.  Used by neededCandidate \
and brCandidates.  O(n log n).\>";\)\), "\[IndentingNewLine]", 
    \(actionBoundaries[sm_] := 
      Union[{minAction, maxAction}, 
        Join @@ \((actionBoundariesSub /@ sm)\)]\)}], "Input"],

Cell[BoxData[{
    \(\(probCandidatesRow::usage = "\<A helper function for epCandidates; \
does what epCandidates does but for just one row of the strategy matrix and \
only for the prob portion of the expected payoff function. O(3).\>";\)\), "\
\[IndentingNewLine]", 
    \(\(probCandidatesRow[action_]\)[{a_, b_, m_, c_}] := 
      Which[\[IndentingNewLine]s3*m > 
          0, {\[IndentingNewLine]0, \[IndentingNewLine]F[b] - 
            F[a], \[IndentingNewLine]F[oppTypeBound[action, s4, m, c]] - 
            F[a], \[IndentingNewLine]F[b] - 
            F[oppTypeBound[action, s1, m, c]], \[IndentingNewLine]F[
              oppTypeBound[action, s4, m, c]] - 
            F[oppTypeBound[action, s1, m, c]]}, \[IndentingNewLine]s3*m < 
          0, {\[IndentingNewLine]0, \[IndentingNewLine]F[b] - 
            F[a], \[IndentingNewLine]F[oppTypeBound[action, s1, m, c]] - 
            F[a], \[IndentingNewLine]F[b] - 
            F[oppTypeBound[action, s4, m, c]], \[IndentingNewLine]F[
              oppTypeBound[action, s1, m, c]] - 
            F[oppTypeBound[action, s4, m, c]]}, \[IndentingNewLine]s3*
            m \[Equal] 0, {0, F[b] - F[a]}]\)}], "Input"],

Cell[BoxData[{
    \( (*\ TODO : \ 
        avoid\ using\ Simplify\ *) \[IndentingNewLine]\(samePolynomial::usage \
= "\<Says if 2 polynomials in var are the same.  O(3).\>";\)\), "\
\[IndentingNewLine]", 
    \(samePolynomial[var_Symbol, polynomial1_, polynomial2_] := 
      If[Collect[polynomial1, var, Simplify] \[Equal] 
          Collect[polynomial2, var, Simplify], True, 
        False,  (*\(Print["\<WARNING (samePolynomial): assuming these \
polynomials are different:\n\>", {Collect[polynomial1, var, Simplify], 
                Collect[polynomial2, var, 
                  Simplify]}];\)*) \[IndentingNewLine]False]\)}], "Input"],

Cell[BoxData[{
    \(\(neededCandidate::usage = "\<Takes an expected payoff function \
candidate (a function of type and action -- type and action need to be \
symbols so we can evaluate the ep candidate at specific representative \
actions and see if we get the same function of type as the real ep) and \
determines whether it is needed by seeing if it matches the actual expected \
payoff function at any of a set of representative actions.  We get the \
representative actions by taking one point in each of the intervals implied \
by actionBoundaries.  We're conservative in that if we can't tell if the \
candidate is equal to ep, we assume it is and say the candidate is needed \
(TODO: trying the liberal approach now which I think is ok since we use \
Collect before comparing; see samePolynomial).  [note that the expected \
payoff candidates are polynomials that the true expected payoff is piecewise \
composed of; TODO: move this explanation to somewhere more appropriate]  Used \
by epCandidatesGeneric.  O(n log n + 2*8n + 3*8n + 8n)\>";\)\), "\
\[IndentingNewLine]", 
    \(\(neededCandidate[type_Symbol, action_Symbol, sm_]\)[epc_] := 
      Module[{repActions}, \[IndentingNewLine]repActions = \((\((#1 + #2)\)/
                  2 &)\) @@@ 
            Partition[actionBoundaries[sm], 2, 
              1]; \[IndentingNewLine]Or @@ \((\(samePolynomial[
                  type, \((epc /. action \[Rule] #)\), ep[type, #, sm]] &\) /@ 
              repActions)\)]\)}], "Input"],

Cell[BoxData[{
    \(\(epCandidatesGeneric::usage = "\<epCandidates in terms of generic \
symbols type and action, as opposed to epCandidates.  Used by epCandidates.  \
O(5^n)  TODO: oops, don't add these indiscriminantly\>";\)\), "\
\[IndentingNewLine]", 
    \(epCandidatesGeneric[type_Symbol, action_Symbol, sm_] := 
      Select[\((s5*type + s6*action + s7)\)*\((Plus @@@ 
              Distribute[probCandidatesRow[action] /@ sm, List])\), 
        neededCandidate[type, action, sm]]\)}], "Input"],

Cell[BoxData[{
    \(\(epCandidates::usage = "\<The expected payoff function has a bunch of \
cases and maxes and mins which means we can't differentiate it, but by \
case-ifying the maxes and mins we can turn it into a big Which statement with \
all the then-parts differentiable.  This function gives a list of the \
differentiable then-parts.  Used in brCandidates and typeBoundaries.\>";\)\), \
"\[IndentingNewLine]", 
    \(epCandidates[type_, action_, sm_] := 
      Module[{t, 
          a}, \[IndentingNewLine]epCandidatesGeneric[t, a, 
            sm] /. {t \[Rule] type, a \[Rule] action}]\)}], "Input"],

Cell[BoxData[{
    \(\(maxima::usage = "\<Returns a list of maxima of f[x] -- TODO: \
currently only works for degree <=2 polynomials, which is all we need for \
piecewise-linear strategies.  TODO: give it the domain and have it check \
boundary conditions and return the actual max.  Used by \
brCandidates.\>";\)\), "\[IndentingNewLine]", 
    \(maxima[f_, x_] := 
      Module[{sol}, \[IndentingNewLine]sol = 
          Check[Solve[D[f, x] \[Equal] 0, 
              x], \((Print["\<ERROR in maxima\>"]; {})\)]; \
\[IndentingNewLine]If[
          sol === {} || sol === {{}} || 
            D[f, {x, 2}] \[GreaterEqual] 
              0, {}, {sol[\([1, 1, 2]\)]}]]\)}], "Input"],

Cell[BoxData[{
    \(\(brCandidates::usage = "\<Best response candidates -- mappings from \
type to action.  Gives all possible maxima of the expected payoff function, \
by setting the derivative with respect to my action to zero, plus all the \
actionBoundaries. The non-boundary critical points will be functions of our \
type.  Used by bestResponseMatrix.\>";\)\), "\[IndentingNewLine]", 
    \(brCandidates[type_, sm_] := 
      Module[{action}, \[IndentingNewLine]Union[actionBoundaries[sm], 
          Union @@ \((\(maxima[#, action] &\) /@ 
                epCandidates[type, action, sm])\)]]\)}], "Input"],

Cell[BoxData[
    \(\(solveForOld[var_]\)[{left_, right_}] := 
      Module[{sol}, \[IndentingNewLine]sol = 
          Check[Solve[left \[Equal] right, 
              var], \((Print["\<ERROR in solveFor[\>", var, "\<][{\>", 
                left, "\<,\>", 
                right, "\<}]\>"]; {})\)]; \[IndentingNewLine]If[
          sol === {} || sol === {{}}, 
          Return[{}]]; \[IndentingNewLine]\(#[\([1, 2]\)] &\) /@ 
          sol]\)], "Input"],

Cell[BoxData[{
    \( (*\ TODO : \ 
        Collect\ instead\ of\ Simplify\ *) \
\[IndentingNewLine]\(solveFor::usage = "\<Takes an expression in var, sets it \
equal to 0, and solves for var, returning a list of the solutions.  Used by \
typeBoundaries.\>";\)\), "\[IndentingNewLine]", 
    \(\(solveFor[var_]\)[expr_ /; Head[expr] =!= List] := 
      Module[{e, sol}, \[IndentingNewLine]e = 
          Identity[Simplify[expr]]; \[IndentingNewLine]sol = 
          Check[Solve[e \[Equal] 0, var], \[IndentingNewLine]If[
              N[Chop[Coefficient[e, var, 2]]] \[Equal] 
                0. , \[IndentingNewLine]Check[
                Solve[Chop[e] \[Equal] 0, 
                  var], \[IndentingNewLine]Print["\<ERROR 1 in solveFor[\>", 
                  var, "\<][\>", 
                  Chop[e], "\<]\>"]; \[IndentingNewLine]Exit[]], \
\[IndentingNewLine]Print["\<ERROR 2 in solveFor[\>", var, "\<][\>", 
                e, "\<]\>"]; \[IndentingNewLine]Exit[]]]; \
\[IndentingNewLine]If[sol === {} || sol === {{}}, 
          Return[{}]]; \[IndentingNewLine]\(#[\([1, 2]\)] &\) /@ 
          sol]\), "\[IndentingNewLine]", 
    \( (*\[IndentingNewLine]degree = Exponent[e, var]; \[IndentingNewLine]If[
        degree <= 0, {}, 
        Check[\(Root[e, #] &\) /@ 
            Range[degree], \((Print["\<ERROR in solveFor[\>", var, "\<][\>", 
              e, "\<]\>"]; {})\)]]*) \)}], "Input"],

Cell[BoxData[{
    \(\(typeBoundaries::usage = "\<Takes our type, and a list of \
best-response candidates which are functions of our type. Our best-response \
function is the 'piecewise-max' of all those functions (ie, f[type]= argmax \
action in {brc1[type],brc2[type],...} of ep[type,action]).  \
TypeBoundaries[t,brclist,sm] takes the list of best response candidate \
functions and the strategy matrix we're responding to and finds all the \
values of type for which the best action function might change.  This will \
happen when the expected payoff for one action function becomes greater than \
another.  So we take each action function (best response candidate) and get \
the expected payoff for it, which is a function of t (TODO: currently using \
all epCandidates so that we have simple functions of t without the maxes and \
mins but we might be able to find the actual expected payoff as a simple \
function of t -- no, probably doch not).  Then we pair each of those with \
each other, set them equal, and solve for t (TODO: a more efficient way).  \
Used by bestResponseMatrix.\>";\)\), "\[IndentingNewLine]", 
    \(typeBoundaries[t_, brclist_, sm_] := 
      Module[{l, i, x}, \[IndentingNewLine]l = 
          brclist; \[IndentingNewLine]l = 
          Join @@ \((\(epCandidates[t, #, sm] &\) /@ 
                l)\); \[IndentingNewLine] (*\ \(l = \(ep[t, #, sm] &\) /@ 
                l;\)\ *) \ \  (*\ 
          TODO : \ will\ this\ work\ ok?\ 
                seems\ no\ *) \[IndentingNewLine]Print["\<[typeBoundaries: \
\>", Length[
            l], "\< epCandidates before pairing with themselves]\>"]; \
\[IndentingNewLine]l = \(Simplify[#, 
                minType \[LessEqual] t \[LessEqual] maxType] &\) /@ 
            l; \[IndentingNewLine]l = 
          Union[l]; \[IndentingNewLine]Print["\<[typeBoundaries: \>", 
          Length[l], "\< (squared is \>", 
          Length[l]^2, "\<) after simplifying and unioning]\>"]; \
\[IndentingNewLine]l = 
          Distribute[{l, l}, List]; \[IndentingNewLine]l = \((#1 - #2 &)\) @@@ 
            l; \[IndentingNewLine]Print["\<[typeBoundaries: just converted \
all \>", Length[l], "\< pairs to differences]\>"]; \[IndentingNewLine]l = 
          Select[Union[
              l], \(! FreeQ[#, 
                  t]\) &]; \[IndentingNewLine]Print["\<[typeBoundaries: \>", 
          Length[l], "\< left after unioning them and removing 0-degree \
polynomials]\>"]; \[IndentingNewLine] (*\ \(l = Simplify /@ l;\)\ *) \ \  (*\ 
          takes\ way\ too\ long\ *) \[IndentingNewLine] (*\ \(l = 
              Union[l];\)\ *) \[IndentingNewLine]Print["\<[typeBoundaries: \
just generated \>", 
          Length[l], "\< pairings of epCandidates]\>"]; \
\[IndentingNewLine]Print["\<[typeBoundaries: setting each pair equal and \
solving for t...]\>"]; \[IndentingNewLine] (*\[IndentingNewLine]\(For[i = 1, 
              i \[LessEqual] Length[l], \(i++\), \[IndentingNewLine]If[
                Mod[i, 20] \[Equal] 0, 
                pout[i, "\<:\n\>", 
                  l[\([i]\)], "\<\n\>"]]; \[IndentingNewLine]l[\([i]\)] = \
\(solveFor[t]\)[l[\([i]\)]]];\)\[IndentingNewLine]*) \[IndentingNewLine]l = 
          solveFor[t] /@ 
            l; \[IndentingNewLine]Print["\<[typeBoundaries: just solved the \
epCandidate pairings for t]\>"]; \[IndentingNewLine]l = 
          Sort[Union[{minType, maxType}, 
              Select[Join @@ 
                  l, \((Im[#] \[Equal] 0 && 
                      minType \[LessEqual] # \[LessEqual] maxType)\) &]], 
            Less]; \[IndentingNewLine]Print["\<[typeBoundaries: settled on \
\>", Length[l], "\< typeBoundaries]\>"]; \[IndentingNewLine]l]\)}], "Input"],

Cell[BoxData[{
    \( (*\ TODO : \ 
        make\ tiebreaker\ default\ to\ picking\ the\ best - 
          response\ candidate\ that' s\ equal\ to\ the\ opponent' 
            s\ strategy\ *) \[IndentingNewLine]\(bestBRC::usage = \
"\<bestBRC[t,brclist,sm] takes a type and a list of best response candidates \
(functions of t) and returns the function that maximizes expected payoff for \
that type.  Note that with a greater-than in the sort function, ties are \
broken in favor of higher actions.  Used by bestResponseMatrix.\>";\)\), "\
\[IndentingNewLine]", 
    \(bestBRC[t_, var_, brclist_, sm_, tiebreaker_:  Less] := 
      argMax[ep[t, \((# /. var \[Rule] t)\), sm] &, 
        Sort[brclist, 
          tiebreaker[\((#1 /. var \[Rule] t)\), \((#2 /. 
                  var \[Rule] t)\)] &]]\)}], "Input"],

Cell[BoxData[
    \(midPoint[{a_, b_}] := \((a + b)\)/2\)], "Input"],

Cell[BoxData[{
    \( (*\ TODO : \ 
        rewrite\ this\ *) \[IndentingNewLine]\(mergeRanges::usage = "\<Takes \
a list of {{a,b},x} pairs and any time there are 2 successive ones with the \
same x, merges them, ie, {{a,b},x},{{b,c},x} becomes {{a,c},x}.\>";\)\), "\
\[IndentingNewLine]", 
    \(mergeRanges[{{{a_, b_}, x_}, {{c_, d_}, y_}, tail___}] := 
      If[Simplify[x] \[Equal] Simplify[y] && b \[Equal] c, 
        mergeRanges[{{{a, d}, x}, tail}], \[IndentingNewLine]Prepend[
          mergeRanges[{{{c, d}, y}, tail}], {{a, b}, 
            x}]]\), "\[IndentingNewLine]", 
    \(mergeRanges[{{range_, val_}}] := {{range, val}}\)}], "Input"],

Cell[BoxData[
    \(mergeRangesSlow[l_] := 
      l //. {begin___, {{a_, b_}, x_}, {{b_, c_}, x_}, 
            end___} \[Rule] {begin, {{a, c}, x}, end}\)], "Input"],

Cell[BoxData[
    \(\(typeRangeAndActionToStrategyRow[type_]\)[{{t1_, t2_}, a_}] := {t1, 
        t2, D[a, type], \((a /. type \[Rule] 0)\)}\)], "Input"],

Cell[BoxData[
    \(bestResponseMatrix[sm_, tiebreaker_:  Less] := 
      Module[{brclist, tblist, pointsAndRanges, t, l, i, n, start, 
          startmem}, \[IndentingNewLine]brclist = 
          brCandidates[t, sm]; \ \  (*\ 
          list\ of\ best - 
            response\ candidates\ as\ funcs\ of\ t\ \
*) \[IndentingNewLine]tblist = 
          typeBoundaries[t, brclist, 
            sm]; \[IndentingNewLine]pointsAndRanges = \({midPoint[#], #} &\) /@ 
            Partition[tblist, 2, 
              1]; \[IndentingNewLine]Print["\<[bestResponseMatrix: Finding BR \
for \>", Length[pointsAndRanges], "\< types]\>"]; \[IndentingNewLine]n = 
          Length[pointsAndRanges]; \[IndentingNewLine]l = 
          Table[0, {n}]; \[IndentingNewLine]For[i = 1, 
          i \[LessEqual] n, \(i++\), \[IndentingNewLine]start = 
            TimeUsed[]; \[IndentingNewLine]startmem = 
            MemoryInUse[]; \[IndentingNewLine]l[\([i]\)] = \
\(Simplify[{#[\([2]\)], bestBRC[#[\([1]\)], t, brclist, sm, tiebreaker]}] &\)[
              pointsAndRanges[\([i]\)]]; \[IndentingNewLine]If[
            i \[Equal] 50 || i \[Equal] 70 || i \[Equal] 100 || 
              i \[Equal] 500 || 
              Mod[i, 1000] \[Equal] 0, \[IndentingNewLine]Print[
              i, "\<: found best response for {type,range} in \>", 
              seconds2str[TimeUsed[] - start], "\< and \>", 
              MemoryInUse[] - 
                startmem, "\< bytes\>"]];\[IndentingNewLine]]; \
\[IndentingNewLine] (*\(l = \({#[\([2]\)], 
                    bestBRC[#[\([1]\)], t, brclist, sm, tiebreaker]} &\) /@ 
                pointsAndRanges;\)*) \[IndentingNewLine]Print["\<{range,BR} \
pairs: \>", l]; \[IndentingNewLine]typeRangeAndActionToStrategyRow[t] /@ 
          mergeRangesSlow[l]]\)], "Input"],

Cell[BoxData[{
    \(\(bestResponse::usage = "\<Takes a strategy -- a function mapping type \
to action -- that is piecewise-linear and returns a best-response strategy \
(which will also be piecewise-linear (TODO prove)).\>";\)\), "\
\[IndentingNewLine]", 
    \(bestResponse[strategy_, tiebreaker_:  Less] := 
      matrixToStrategy[
        bestResponseMatrix[strategyToMatrix[strategy], 
          tiebreaker]]\)}], "Input"]
}, Open  ]],

Cell[CellGroupData[{

Cell["SCRATCH", "Section"],

Cell[BoxData[{
    \(\(paperStrategy[v_]\)[c_] := 
      Which[0 \[LessEqual] c \[LessEqual] v - 1, 1/2*c + v/2 - 1/4, 
        v - 1 \[LessEqual] c \[LessEqual] 1, 
        3/4*c + v/4]\), "\[IndentingNewLine]", 
    \(\(fixedPriceStrategy[p_, v_]\)[c_] := 
      Which[0 \[LessEqual] c \[LessEqual] p, p, 
        p \[LessEqual] c \[LessEqual] 1, v]\), "\[IndentingNewLine]", 
    \(\(linearStrategy[v_]\)[c_] := 
      Which[0 \[LessEqual] c \[LessEqual] 1, 
        c/2 + v/3]\), "\[IndentingNewLine]", 
    \(\(linearStrategy2[v_]\)[c_] := 
      Which[0 \[LessEqual] c \[LessEqual] 2/3*v - 1, 2/3*v - 1/2, 
        2/3*v - 1 \[LessEqual] c \[LessEqual] 1, 
        c/2 + v/3]\), "\[IndentingNewLine]", 
    \(\(testStrategy[v_]\)[c_] := 
      Which[0 \[LessEqual] c \[LessEqual] 1, \((v + c)\)/
          2]\), "\[IndentingNewLine]", 
    \(truthTellingStrategy[c_] := 
      Which[0 \[LessEqual] c \[LessEqual] 1, c]\)}], "Input"],

Cell[BoxData[
    \(\(v = \((10 - \@5)\)/5. ;\)\)], "Input"],

Cell[BoxData[
    \(\(v = 2;\)\)], "Input"],

Cell[CellGroupData[{

Cell[BoxData[
    \(bestResponse[linearStrategy[v]]\)], "Input"],

Cell[BoxData[
    InterpretationBox[\("[typeBoundaries: "\[InvisibleSpace]25\
\[InvisibleSpace]" epCandidates before pairing with themselves]"\),
      SequenceForm[ 
      "[typeBoundaries: ", 25, 
        " epCandidates before pairing with themselves]"],
      Editable->False]], "Print"],

Cell[BoxData[
    \("[typeBoundaries: just simplified them all]"\)], "Print"],

Cell[BoxData[
    InterpretationBox[\("[typeBoundaries: just converted all "\
\[InvisibleSpace]625\[InvisibleSpace]" pairs to differences]"\),
      SequenceForm[ 
      "[typeBoundaries: just converted all ", 625, " pairs to differences]"],
      Editable->False]], "Print"],

Cell[BoxData[
    InterpretationBox[\("[typeBoundaries: "\[InvisibleSpace]295\
\[InvisibleSpace]" left after unioning them and removing 0-degree \
polynomials]"\),
      SequenceForm[ 
      "[typeBoundaries: ", 295, 
        " left after unioning them and removing 0-degree polynomials]"],
      Editable->False]], "Print"],

Cell[BoxData[
    InterpretationBox[\("[typeBoundaries: just generated \
"\[InvisibleSpace]295\[InvisibleSpace]" pairings of epCandidates]"\),
      SequenceForm[ 
      "[typeBoundaries: just generated ", 295, " pairings of epCandidates]"],
      Editable->False]], "Print"],

Cell["\<\
[typeBoundaries: setting each pair equal and solving for t...]\
\>", "Print"],

Cell[BoxData[
    \("[typeBoundaries: just solved the epCandidate pairings for t]"\)], \
"Print"],

Cell[BoxData[
    InterpretationBox[\("[typeBoundaries: settled on "\[InvisibleSpace]19\
\[InvisibleSpace]" typeBoundaries]"\),
      SequenceForm[ "[typeBoundaries: settled on ", 19, " typeBoundaries]"],
      Editable->False]], "Print"],

Cell[BoxData[
    \(Function[type$, 
      Which[0 \[LessEqual] 
          type$ \[LessEqual] \(12 - 5\ \@5\)\/\(30 - 3\ \@5\), 
        5\/6 - 2\/\(3\ \@5\), \(12 - 5\ \@5\)\/\(30 - 3\ \@5\) \[LessEqual] 
          type$ \[LessEqual] 1, 
        1\/30\ \((20 - 2\ \@5)\) + type$\/2]]\)], "Output"]
}, Open  ]],

Cell[CellGroupData[{

Cell[BoxData[
    \(bestResponse[linearStrategy[v]]\)], "Input"],

Cell[BoxData[
    InterpretationBox[\("[typeBoundaries: "\[InvisibleSpace]15\
\[InvisibleSpace]" epCandidates before pairing with themselves]"\),
      SequenceForm[ 
      "[typeBoundaries: ", 15, 
        " epCandidates before pairing with themselves]"],
      Editable->False]], "Print"],

Cell[BoxData[
    InterpretationBox[\("[typeBoundaries: "\[InvisibleSpace]11\
\[InvisibleSpace]" (squared is "\[InvisibleSpace]121\[InvisibleSpace]") after \
simplifying and unioning]"\),
      SequenceForm[ 
      "[typeBoundaries: ", 11, " (squared is ", 121, 
        ") after simplifying and unioning]"],
      Editable->False]], "Print"],

Cell[BoxData[
    InterpretationBox[\("[typeBoundaries: just converted all "\
\[InvisibleSpace]121\[InvisibleSpace]" pairs to differences]"\),
      SequenceForm[ 
      "[typeBoundaries: just converted all ", 121, " pairs to differences]"],
      Editable->False]], "Print"],

Cell[BoxData[
    InterpretationBox[\("[typeBoundaries: "\[InvisibleSpace]88\
\[InvisibleSpace]" left after unioning them and removing 0-degree \
polynomials]"\),
      SequenceForm[ 
      "[typeBoundaries: ", 88, 
        " left after unioning them and removing 0-degree polynomials]"],
      Editable->False]], "Print"],

Cell[BoxData[
    InterpretationBox[\("[typeBoundaries: just generated "\[InvisibleSpace]88\
\[InvisibleSpace]" pairings of epCandidates]"\),
      SequenceForm[ 
      "[typeBoundaries: just generated ", 88, " pairings of epCandidates]"],
      Editable->False]], "Print"],

Cell[BoxData[
    \("[typeBoundaries: setting each pair equal and solving for t...]"\)], \
"Print"],

Cell[BoxData[
    \("[typeBoundaries: just solved the epCandidate pairings for t]"\)], \
"Print"],

Cell[BoxData[
    InterpretationBox[\("[typeBoundaries: settled on "\[InvisibleSpace]12\
\[InvisibleSpace]" typeBoundaries]"\),
      SequenceForm[ "[typeBoundaries: settled on ", 12, " typeBoundaries]"],
      Editable->False]], "Print"],

Cell[BoxData[
    InterpretationBox[\("[bestResponseMatrix: Finding BR for "\
\[InvisibleSpace]11\[InvisibleSpace]" types]"\),
      SequenceForm[ "[bestResponseMatrix: Finding BR for ", 11, " types]"],
      Editable->False]], "Print"],

Cell[BoxData[
    InterpretationBox[\("{range,BR} pairs: "\[InvisibleSpace]{{{0.`, 0}, 
            0.5351909363333615`}, {{0, 0.035190932793583`}, 
            0.5351909363333615`}, {{0.035190932793583`, 
              0.035190936333361345`}, 
            0.5351909363333615`}, {{0.035190936333361345`, 
              0.03519093633336154`}, \(\(0.5175954681666808`\)\(\
\[InvisibleSpace]\)\) + 0.5`\ t$13}, {{0.03519093633336154`, 
              0.03519093633336155`}, \(\(0.5175954681666808`\)\(\
\[InvisibleSpace]\)\) + 0.5`\ t$13}, {{0.03519093633336155`, 
              0.03519093987313969`}, \(\(0.5175954681666808`\)\(\
\[InvisibleSpace]\)\) + 0.5`\ t$13}, {{0.03519093987313969`, 
              0.5`}, \(\(0.5175954681666808`\)\(\[InvisibleSpace]\)\) + 
              0.5`\ t$13}, {{0.5`, 
              0.5175954681666806`}, \(\(0.5175954681666808`\)\(\
\[InvisibleSpace]\)\) + 0.5`\ t$13}, {{0.5175954681666806`, 
              0.5351909363333615`}, \(\(0.5175954681666808`\)\(\
\[InvisibleSpace]\)\) + 0.5`\ t$13}, {{0.5351909363333615`, 
              0.7898179887220259`}, \(\(0.5175954681666808`\)\(\
\[InvisibleSpace]\)\) + 0.5`\ t$13}, {{0.7898179887220259`, 
              1}, \(\(0.5175954681666808`\)\(\[InvisibleSpace]\)\) + 
              0.5`\ t$13}}\),
      SequenceForm[ 
      "{range,BR} pairs: ", {{{-0.0, 0}, 0.53519093633336146}, {{0, 
        0.035190932793582999}, 0.53519093633336146}, {{0.035190932793582999, 
        0.035190936333361345}, 0.53519093633336146}, {{0.035190936333361345, 
        0.035190936333361539}, 
        Plus[ 0.51759546816668078, 
          Times[ 0.5, t$13]]}, {{0.035190936333361539, 0.035190936333361553}, 
        
        Plus[ 0.51759546816668078, 
          Times[ 0.5, t$13]]}, {{0.035190936333361553, 0.03519093987313969}, 
        Plus[ 0.51759546816668078, 
          Times[ 0.5, t$13]]}, {{0.03519093987313969, 0.5}, 
        Plus[ 0.51759546816668078, 
          Times[ 0.5, t$13]]}, {{0.5, 0.51759546816668056}, 
        Plus[ 0.51759546816668078, 
          Times[ 0.5, t$13]]}, {{0.51759546816668056, 0.53519093633336146}, 
        Plus[ 0.51759546816668078, 
          Times[ 0.5, t$13]]}, {{0.53519093633336146, 0.78981798872202591}, 
        Plus[ 0.51759546816668078, 
          Times[ 0.5, t$13]]}, {{0.78981798872202591, 1}, 
        Plus[ 0.51759546816668078, 
          Times[ 0.5, t$13]]}}],
      Editable->False]], "Print"],

Cell[BoxData[
    \(Function[type$, 
      Which[0.` \[LessEqual] type$ \[LessEqual] 0.035190936333361345`, 
        0.5351909363333615`, 
        0.035190936333361345` \[LessEqual] type$ \[LessEqual] 
          1, \(\(0.5175954681666808`\)\(\[InvisibleSpace]\)\) + 
          0.5`\ type$]]\)], "Output"]
}, Open  ]],

Cell[CellGroupData[{

Cell[BoxData[
    \(bestResponse[paperStrategy[v]]\)], "Input"],

Cell[BoxData[
    InterpretationBox[\("[typeBoundaries: "\[InvisibleSpace]60\
\[InvisibleSpace]" epCandidates before pairing with themselves]"\),
      SequenceForm[ 
      "[typeBoundaries: ", 60, 
        " epCandidates before pairing with themselves]"],
      Editable->False]], "Print"],

Cell[BoxData[
    InterpretationBox[\("[typeBoundaries: "\[InvisibleSpace]45\
\[InvisibleSpace]" (squared is "\[InvisibleSpace]2025\[InvisibleSpace]") \
after simplifying and unioning]"\),
      SequenceForm[ 
      "[typeBoundaries: ", 45, " (squared is ", 2025, 
        ") after simplifying and unioning]"],
      Editable->False]], "Print"],

Cell[BoxData[
    InterpretationBox[\("[typeBoundaries: just converted all "\
\[InvisibleSpace]2025\[InvisibleSpace]" pairs to differences]"\),
      SequenceForm[ 
      "[typeBoundaries: just converted all ", 2025, " pairs to differences]"],
      
      Editable->False]], "Print"],

Cell[BoxData[
    InterpretationBox[\("[typeBoundaries: "\[InvisibleSpace]1890\
\[InvisibleSpace]" left after unioning them and removing 0-degree \
polynomials]"\),
      SequenceForm[ 
      "[typeBoundaries: ", 1890, 
        " left after unioning them and removing 0-degree polynomials]"],
      Editable->False]], "Print"],

Cell[BoxData[
    InterpretationBox[\("[typeBoundaries: just generated \
"\[InvisibleSpace]1890\[InvisibleSpace]" pairings of epCandidates]"\),
      SequenceForm[ 
      "[typeBoundaries: just generated ", 1890, " pairings of epCandidates]"],
      
      Editable->False]], "Print"],

Cell[BoxData[
    \("[typeBoundaries: setting each pair equal and solving for t...]"\)], \
"Print"],

Cell[BoxData[
    \("[typeBoundaries: just solved the epCandidate pairings for t]"\)], \
"Print"],

Cell[BoxData[
    InterpretationBox[\("[typeBoundaries: settled on "\[InvisibleSpace]329\
\[InvisibleSpace]" typeBoundaries]"\),
      SequenceForm[ "[typeBoundaries: settled on ", 329, " typeBoundaries]"],
      Editable->False]], "Print"],

Cell[BoxData[
    InterpretationBox[\("[bestResponseMatrix: Finding BR for "\
\[InvisibleSpace]328\[InvisibleSpace]" types]"\),
      SequenceForm[ "[bestResponseMatrix: Finding BR for ", 328, " types]"],
      Editable->False]], "Print"],

Cell[BoxData[
    InterpretationBox[\(50\[InvisibleSpace]": found best response for \
{type,range} in "\[InvisibleSpace]"0.02s"\[InvisibleSpace]" and "\
\[InvisibleSpace]516\[InvisibleSpace]" bytes"\),
      SequenceForm[ 
      50, ": found best response for {type,range} in ", "0.02s", " and ", 516,
         " bytes"],
      Editable->False]], "Print"],

Cell[BoxData[
    InterpretationBox[\(70\[InvisibleSpace]": found best response for \
{type,range} in "\[InvisibleSpace]"0.03s"\[InvisibleSpace]" and "\
\[InvisibleSpace]516\[InvisibleSpace]" bytes"\),
      SequenceForm[ 
      70, ": found best response for {type,range} in ", "0.03s", " and ", 516,
         " bytes"],
      Editable->False]], "Print"],

Cell[BoxData[
    InterpretationBox[\(100\[InvisibleSpace]": found best response for \
{type,range} in "\[InvisibleSpace]"0.02s"\[InvisibleSpace]" and "\
\[InvisibleSpace]468\[InvisibleSpace]" bytes"\),
      SequenceForm[ 
      100, ": found best response for {type,range} in ", "0.02s", " and ", 
        468, " bytes"],
      Editable->False]], "Print"],

Cell[BoxData[
    \(Function[type$, 
      Which[0.` \[LessEqual] type$ \[LessEqual] 
          0.33541019662496846`, \
\(\(0.5822949016875159`\)\(\[InvisibleSpace]\)\) + 0.5`\ type$, 
        0.33541019662496846` \[LessEqual] type$ \[LessEqual] 
          0.4736067977499786`, 0.75`, 
        0.4736067977499786` \[LessEqual] type$ \[LessEqual] 
          0.47360679774997916`, \
\(\(0.5131966011250105`\)\(\[InvisibleSpace]\)\) + 0.5`\ type$, 
        0.47360679774997916` \[LessEqual] type$ \[LessEqual] 
          0.47360680606822025`, 0.75`, 
        0.47360680606822025` \[LessEqual] type$ \[LessEqual] 
          1, \(\(0.5131966011250105`\)\(\[InvisibleSpace]\)\) + 
          0.5`\ type$]]\)], "Output"]
}, Open  ]],

Cell[CellGroupData[{

Cell[BoxData[
    \(bestResponse[%]\)], "Input"],

Cell[BoxData[
    InterpretationBox[\("[typeBoundaries: "\[InvisibleSpace]506\
\[InvisibleSpace]" epCandidates before pairing with themselves]"\),
      SequenceForm[ 
      "[typeBoundaries: ", 506, 
        " epCandidates before pairing with themselves]"],
      Editable->False]], "Print"],

Cell[BoxData[
    InterpretationBox[\("[typeBoundaries: "\[InvisibleSpace]244\
\[InvisibleSpace]" (squared is "\[InvisibleSpace]59536\[InvisibleSpace]") \
after simplifying and unioning]"\),
      SequenceForm[ 
      "[typeBoundaries: ", 244, " (squared is ", 59536, 
        ") after simplifying and unioning]"],
      Editable->False]], "Print"],

Cell[BoxData[
    InterpretationBox[\("[typeBoundaries: just converted all "\
\[InvisibleSpace]59536\[InvisibleSpace]" pairs to differences]"\),
      SequenceForm[ 
      "[typeBoundaries: just converted all ", 59536, 
        " pairs to differences]"],
      Editable->False]], "Print"],

Cell[BoxData[
    InterpretationBox[\("[typeBoundaries: "\[InvisibleSpace]54630\
\[InvisibleSpace]" left after unioning them and removing 0-degree \
polynomials]"\),
      SequenceForm[ 
      "[typeBoundaries: ", 54630, 
        " left after unioning them and removing 0-degree polynomials]"],
      Editable->False]], "Print"],

Cell[BoxData[
    InterpretationBox[\("[typeBoundaries: just generated \
"\[InvisibleSpace]54630\[InvisibleSpace]" pairings of epCandidates]"\),
      SequenceForm[ 
      "[typeBoundaries: just generated ", 54630, 
        " pairings of epCandidates]"],
      Editable->False]], "Print"],

Cell[BoxData[
    \("[typeBoundaries: setting each pair equal and solving for t...]"\)], \
"Print"],

Cell[BoxData[
    \(Solve::"tdep" \(\(:\)\(\ \)\) 
      "The equations appear to involve the variables to be solved for in an \
essentially non-algebraic way."\)], "Message"],

Cell[BoxData[
    \(Solve::"tdep" \(\(:\)\(\ \)\) 
      "The equations appear to involve the variables to be solved for in an \
essentially non-algebraic way."\)], "Message"],

Cell[BoxData[
    \(Solve::"tdep" \(\(:\)\(\ \)\) 
      "The equations appear to involve the variables to be solved for in an \
essentially non-algebraic way."\)], "Message"],

Cell[BoxData[
    \(General::"stop" \(\(:\)\(\ \)\) 
      "Further output of \!\(Solve :: \"tdep\"\) will be suppressed during \
this calculation."\)], "Message"],

Cell[BoxData[
    \("[typeBoundaries: just solved the epCandidate pairings for t]"\)], \
"Print"],

Cell[BoxData[
    InterpretationBox[\("[typeBoundaries: settled on "\[InvisibleSpace]10312\
\[InvisibleSpace]" typeBoundaries]"\),
      SequenceForm[ 
      "[typeBoundaries: settled on ", 10312, " typeBoundaries]"],
      Editable->False]], "Print"],

Cell[BoxData[
    InterpretationBox[\("[bestResponseMatrix: Finding BR for "\
\[InvisibleSpace]10311\[InvisibleSpace]" types]"\),
      SequenceForm[ "[bestResponseMatrix: Finding BR for ", 10311, " types]"],
      
      Editable->False]], "Print"],

Cell[BoxData[
    InterpretationBox[\(50\[InvisibleSpace]": found best response for \
{type,range} in "\[InvisibleSpace]"0.1s"\[InvisibleSpace]" and "\
\[InvisibleSpace]52\[InvisibleSpace]" bytes"\),
      SequenceForm[ 
      50, ": found best response for {type,range} in ", "0.1s", " and ", 52, 
        " bytes"],
      Editable->False]], "Print"],

Cell[BoxData[
    InterpretationBox[\(70\[InvisibleSpace]": found best response for \
{type,range} in "\[InvisibleSpace]"0.1s"\[InvisibleSpace]" and "\
\[InvisibleSpace]108\[InvisibleSpace]" bytes"\),
      SequenceForm[ 
      70, ": found best response for {type,range} in ", "0.1s", " and ", 108, 
        " bytes"],
      Editable->False]], "Print"],

Cell[BoxData[
    InterpretationBox[\(100\[InvisibleSpace]": found best response for \
{type,range} in "\[InvisibleSpace]"0.1s"\[InvisibleSpace]" and "\
\[InvisibleSpace]36\[InvisibleSpace]" bytes"\),
      SequenceForm[ 
      100, ": found best response for {type,range} in ", "0.1s", " and ", 36, 
        " bytes"],
      Editable->False]], "Print"],

Cell[BoxData[
    InterpretationBox[\(500\[InvisibleSpace]": found best response for \
{type,range} in "\[InvisibleSpace]"0.1s"\[InvisibleSpace]" and "\
\[InvisibleSpace]220\[InvisibleSpace]" bytes"\),
      SequenceForm[ 
      500, ": found best response for {type,range} in ", "0.1s", " and ", 220,
         " bytes"],
      Editable->False]], "Print"],

Cell[BoxData[
    InterpretationBox[\(1000\[InvisibleSpace]": found best response for \
{type,range} in "\[InvisibleSpace]"0.11s"\[InvisibleSpace]" and "\
\[InvisibleSpace]68\[InvisibleSpace]" bytes"\),
      SequenceForm[ 
      1000, ": found best response for {type,range} in ", "0.11s", " and ", 
        68, " bytes"],
      Editable->False]], "Print"],

Cell[BoxData[
    InterpretationBox[\(2000\[InvisibleSpace]": found best response for \
{type,range} in "\[InvisibleSpace]"0.1s"\[InvisibleSpace]" and "\
\[InvisibleSpace]\(-288\)\[InvisibleSpace]" bytes"\),
      SequenceForm[ 
      2000, ": found best response for {type,range} in ", "0.1s", 
        " and ", -288, " bytes"],
      Editable->False]], "Print"],

Cell[BoxData[
    InterpretationBox[\(3000\[InvisibleSpace]": found best response for \
{type,range} in "\[InvisibleSpace]"0.1s"\[InvisibleSpace]" and "\
\[InvisibleSpace]52\[InvisibleSpace]" bytes"\),
      SequenceForm[ 
      3000, ": found best response for {type,range} in ", "0.1s", " and ", 52,
         " bytes"],
      Editable->False]], "Print"],

Cell[BoxData[
    InterpretationBox[\(4000\[InvisibleSpace]": found best response for \
{type,range} in "\[InvisibleSpace]"0.11s"\[InvisibleSpace]" and "\
\[InvisibleSpace]100\[InvisibleSpace]" bytes"\),
      SequenceForm[ 
      4000, ": found best response for {type,range} in ", "0.11s", " and ", 
        100, " bytes"],
      Editable->False]], "Print"],

Cell[BoxData[
    InterpretationBox[\(5000\[InvisibleSpace]": found best response for \
{type,range} in "\[InvisibleSpace]"0.11s"\[InvisibleSpace]" and "\
\[InvisibleSpace]\(-272\)\[InvisibleSpace]" bytes"\),
      SequenceForm[ 
      5000, ": found best response for {type,range} in ", "0.11s", 
        " and ", -272, " bytes"],
      Editable->False]], "Print"],

Cell[BoxData[
    InterpretationBox[\(6000\[InvisibleSpace]": found best response for \
{type,range} in "\[InvisibleSpace]"0.1s"\[InvisibleSpace]" and "\
\[InvisibleSpace]76\[InvisibleSpace]" bytes"\),
      SequenceForm[ 
      6000, ": found best response for {type,range} in ", "0.1s", " and ", 76,
         " bytes"],
      Editable->False]], "Print"],

Cell[BoxData[
    InterpretationBox[\(7000\[InvisibleSpace]": found best response for \
{type,range} in "\[InvisibleSpace]"0.1s"\[InvisibleSpace]" and "\
\[InvisibleSpace]\(-100\)\[InvisibleSpace]" bytes"\),
      SequenceForm[ 
      7000, ": found best response for {type,range} in ", "0.1s", 
        " and ", -100, " bytes"],
      Editable->False]], "Print"],

Cell[BoxData[
    InterpretationBox[\(8000\[InvisibleSpace]": found best response for \
{type,range} in "\[InvisibleSpace]"0.1s"\[InvisibleSpace]" and "\
\[InvisibleSpace]176\[InvisibleSpace]" bytes"\),
      SequenceForm[ 
      8000, ": found best response for {type,range} in ", "0.1s", " and ", 
        176, " bytes"],
      Editable->False]], "Print"],

Cell[BoxData[
    InterpretationBox[\(9000\[InvisibleSpace]": found best response for \
{type,range} in "\[InvisibleSpace]"0.1s"\[InvisibleSpace]" and "\
\[InvisibleSpace]\(-76\)\[InvisibleSpace]" bytes"\),
      SequenceForm[ 
      9000, ": found best response for {type,range} in ", "0.1s", 
        " and ", -76, " bytes"],
      Editable->False]], "Print"],

Cell[BoxData[
    InterpretationBox[\(10000\[InvisibleSpace]": found best response for \
{type,range} in "\[InvisibleSpace]"0.11s"\[InvisibleSpace]" and "\
\[InvisibleSpace]12\[InvisibleSpace]" bytes"\),
      SequenceForm[ 
      10000, ": found best response for {type,range} in ", "0.11s", " and ", 
        12, " bytes"],
      Editable->False]], "Print"],

Cell[BoxData[
    \(Function[type$, 
      Which[0.` \[LessEqual] type$ \[LessEqual] 0.03958979921591026`, 
        0.5395898033750316`, 
        0.03958979921591026` \[LessEqual] type$ \[LessEqual] 
          0.03958979921591192`, \
\(\(0.5197949037670762`\)\(\[InvisibleSpace]\)\) + 0.5`\ type$, 
        0.03958979921591192` \[LessEqual] type$ \[LessEqual] 
          0.0395897992159121`, 0.5395898033750316`, 
        0.0395897992159121` \[LessEqual] type$ \[LessEqual] 
          0.03958979921591471`, \
\(\(0.5197949037670762`\)\(\[InvisibleSpace]\)\) + 0.5`\ type$, 
        0.03958979921591471` \[LessEqual] type$ \[LessEqual] 
          0.03958979921591625`, 0.5395898033750316`, 
        0.03958979921591625` \[LessEqual] type$ \[LessEqual] 
          0.03958980208454614`, \(\(0.519794903767076`\)\(\[InvisibleSpace]\)\
\) + 0.5`\ type$, 
        0.03958980208454614` \[LessEqual] type$ \[LessEqual] 
          0.03958980208454629`, 0.5395898033750316`, 
        0.03958980208454629` \[LessEqual] type$ \[LessEqual] 
          0.039589802084546696`, \(\(0.5197949037670762`\)\(\[InvisibleSpace]\
\)\) + 0.5`\ type$, 
        0.039589802084546696` \[LessEqual] type$ \[LessEqual] 
          0.03958980208454684`, 0.5395898033750316`, 
        0.03958980208454684` \[LessEqual] type$ \[LessEqual] 
          0.03958980208454696`, \(\(0.519794903767076`\)\(\[InvisibleSpace]\)\
\) + 0.5`\ type$, 
        0.03958980208454696` \[LessEqual] type$ \[LessEqual] 
          0.03958980208454725`, 0.5395898033750316`, 
        0.03958980208454725` \[LessEqual] type$ \[LessEqual] 
          0.039589803375029195`, \
\(\(0.519794903767076`\)\(\[InvisibleSpace]\)\) + 0.5`\ type$, 
        0.039589803375029195` \[LessEqual] type$ \[LessEqual] 
          0.03958980337502964`, 0.5395898033750316`, 
        0.03958980337502964` \[LessEqual] type$ \[LessEqual] 
          0.0395898033750304`, \
\(\(0.519794903767076`\)\(\[InvisibleSpace]\)\) + 0.5`\ type$, 
        0.0395898033750304` \[LessEqual] type$ \[LessEqual] 
          0.03958980337503054`, 0.5395898033750316`, 
        0.03958980337503054` \[LessEqual] type$ \[LessEqual] 
          0.039589803375031166`, \(\(0.5197949037670762`\)\(\[InvisibleSpace]\
\)\) + 0.5`\ type$, 
        0.039589803375031166` \[LessEqual] type$ \[LessEqual] 
          0.03958980337503137`, \
\(\(0.5197949016875159`\)\(\[InvisibleSpace]\)\) + 0.5`\ type$, 
        0.03958980337503137` \[LessEqual] type$ \[LessEqual] 
          0.0395898033750316`, \
\(\(0.519794903767076`\)\(\[InvisibleSpace]\)\) + 0.5`\ type$, 
        0.0395898033750316` \[LessEqual] type$ \[LessEqual] 
          0.03958980337503164`, \
\(\(0.5197949016875159`\)\(\[InvisibleSpace]\)\) + 0.5`\ type$, 
        0.03958980337503164` \[LessEqual] type$ \[LessEqual] 
          0.03958980337503176`, \(\(0.519794903767076`\)\(\[InvisibleSpace]\)\
\) + 0.5`\ type$, 
        0.03958980337503176` \[LessEqual] type$ \[LessEqual] 
          0.039589803375032484`, \(\(0.5197949016875159`\)\(\[InvisibleSpace]\
\)\) + 0.5`\ type$, 
        0.039589803375032484` \[LessEqual] type$ \[LessEqual] 
          0.03958980337503255`, \(\(0.519794903767076`\)\(\[InvisibleSpace]\)\
\) + 0.5`\ type$, 
        0.03958980337503255` \[LessEqual] type$ \[LessEqual] 
          0.03958980337503257`, \
\(\(0.5197949016875157`\)\(\[InvisibleSpace]\)\) + 0.5`\ type$, 
        0.03958980337503257` \[LessEqual] type$ \[LessEqual] 
          0.03958980337503261`, \(\(0.519794903767076`\)\(\[InvisibleSpace]\)\
\) + 0.5`\ type$, 
        0.03958980337503261` \[LessEqual] type$ \[LessEqual] 
          0.03958980337503317`, \
\(\(0.5197949016875157`\)\(\[InvisibleSpace]\)\) + 0.5`\ type$, 
        0.03958980337503317` \[LessEqual] type$ \[LessEqual] 
          0.03958980337503369`, \(\(0.519794903767076`\)\(\[InvisibleSpace]\)\
\) + 0.5`\ type$, 
        0.03958980337503369` \[LessEqual] type$ \[LessEqual] 
          0.03958980753415195`, \
\(\(0.5197949016875157`\)\(\[InvisibleSpace]\)\) + 0.5`\ type$, 
        0.03958980753415195` \[LessEqual] type$ \[LessEqual] 
          0.03958980753415199`, \(\(0.519794903767076`\)\(\[InvisibleSpace]\)\
\) + 0.5`\ type$, 
        0.03958980753415199` \[LessEqual] type$ \[LessEqual] 
          0.039589807534152636`, \(\(0.5197949016875159`\)\(\[InvisibleSpace]\
\)\) + 0.5`\ type$, 
        0.039589807534152636` \[LessEqual] type$ \[LessEqual] 
          
          0.03958980753415283`, \(\(0.519794903767076`\)\(\[InvisibleSpace]\)\
\) + 0.5`\ type$, 
        0.03958980753415283` \[LessEqual] type$ \[LessEqual] 
          0.039589808824637744`, \(\(0.5197949016875157`\)\(\[InvisibleSpace]\
\)\) + 0.5`\ type$, 
        0.039589808824637744` \[LessEqual] type$ \[LessEqual] 
          0.03958980882463788`, \(\(0.519794903767076`\)\(\[InvisibleSpace]\)\
\) + 0.5`\ type$, 
        0.03958980882463788` \[LessEqual] type$ \[LessEqual] 
          0.03958980882463834`, \
\(\(0.5197949016875159`\)\(\[InvisibleSpace]\)\) + 0.5`\ type$, 
        0.03958980882463834` \[LessEqual] type$ \[LessEqual] 
          0.03958981116061207`, \(\(0.519794903767076`\)\(\[InvisibleSpace]\)\
\) + 0.5`\ type$, 
        0.03958981116061207` \[LessEqual] type$ \[LessEqual] 
          0.03958981298375797`, \
\(\(0.5197949016875157`\)\(\[InvisibleSpace]\)\) + 0.5`\ type$, 
        0.03958981298375797` \[LessEqual] type$ \[LessEqual] 
          0.03958981298375812`, \(\(0.519794903767076`\)\(\[InvisibleSpace]\)\
\) + 0.5`\ type$, 
        0.03958981298375812` \[LessEqual] type$ \[LessEqual] 
          0.03958981427424365`, \
\(\(0.5197949016875157`\)\(\[InvisibleSpace]\)\) + 0.5`\ type$, 
        0.03958981427424365` \[LessEqual] type$ \[LessEqual] 
          0.0395898167795123`, \
\(\(0.519794903767076`\)\(\[InvisibleSpace]\)\) + 0.5`\ type$, 
        0.0395898167795123` \[LessEqual] type$ \[LessEqual] 
          0.039680999448120556`, \(\(0.5197949016875157`\)\(\[InvisibleSpace]\
\)\) + 0.5`\ type$, 
        0.039680999448120556` \[LessEqual] type$ \[LessEqual] 
          0.03968099944924124`, \(\(0.519794903767076`\)\(\[InvisibleSpace]\)\
\) + 0.5`\ type$, 
        0.03968099944924124` \[LessEqual] type$ \[LessEqual] 
          0.04930339690107599`, \
\(\(0.5197949016875159`\)\(\[InvisibleSpace]\)\) + 0.5`\ type$, 
        0.04930339690107599` \[LessEqual] type$ \[LessEqual] 
          0.049303398769342484`, \
\(\(0.519794903767076`\)\(\[InvisibleSpace]\)\) + 0.5`\ type$, 
        0.049303398769342484` \[LessEqual] type$ \[LessEqual] 
          0.055088219065756054`, \(\(0.5197949016875157`\)\(\[InvisibleSpace]\
\)\) + 0.5`\ type$, 
        0.055088219065756054` \[LessEqual] type$ \[LessEqual] 
          0.05508821906575635`, \(\(0.519794903767076`\)\(\[InvisibleSpace]\)\
\) + 0.5`\ type$, 
        0.05508821906575635` \[LessEqual] type$ \[LessEqual] 
          0.055088224265529166`, \(\(0.5197949016875159`\)\(\[InvisibleSpace]\
\)\) + 0.5`\ type$, 
        0.055088224265529166` \[LessEqual] type$ \[LessEqual] 
          0.0550882247460638`, \
\(\(0.519794903767076`\)\(\[InvisibleSpace]\)\) + 0.5`\ type$, 
        0.0550882247460638` \[LessEqual] type$ \[LessEqual] 
          0.055088224746064784`, \(\(0.5197949016875157`\)\(\[InvisibleSpace]\
\)\) + 0.5`\ type$, 
        0.055088224746064784` \[LessEqual] type$ \[LessEqual] 
          0.05508822474606509`, \(\(0.519794903767076`\)\(\[InvisibleSpace]\)\
\) + 0.5`\ type$, 
        0.05508822474606509` \[LessEqual] type$ \[LessEqual] 
          0.058423303326307435`, \(\(0.5197949016875157`\)\(\[InvisibleSpace]\
\)\) + 0.5`\ type$, 
        0.058423303326307435` \[LessEqual] type$ \[LessEqual] 
          0.05842330332630758`, \(\(0.519794903767076`\)\(\[InvisibleSpace]\)\
\) + 0.5`\ type$, 
        0.05842330332630758` \[LessEqual] type$ \[LessEqual] 
          0.05842330827213263`, \
\(\(0.5197949016875157`\)\(\[InvisibleSpace]\)\) + 0.5`\ type$, 
        0.05842330827213263` \[LessEqual] type$ \[LessEqual] 
          0.05842330827213278`, \(\(0.519794903767076`\)\(\[InvisibleSpace]\)\
\) + 0.5`\ type$, 
        0.05842330827213278` \[LessEqual] type$ \[LessEqual] 
          0.0584233082721335`, \(\(0.5197949016875157`\)\(\[InvisibleSpace]\)\
\) + 0.5`\ type$, 
        0.0584233082721335` \[LessEqual] type$ \[LessEqual] 
          0.05842330905883761`, \(\(0.519794903767076`\)\(\[InvisibleSpace]\)\
\) + 0.5`\ type$, 
        0.05842330905883761` \[LessEqual] type$ \[LessEqual] 
          0.05842330905883818`, \
\(\(0.5197949016875159`\)\(\[InvisibleSpace]\)\) + 0.5`\ type$, 
        0.05842330905883818` \[LessEqual] type$ \[LessEqual] 
          0.05842330905883844`, \(\(0.519794903767076`\)\(\[InvisibleSpace]\)\
\) + 0.5`\ type$, 
        0.05842330905883844` \[LessEqual] type$ \[LessEqual] 
          
          0.0584233090588386`, \(\(0.5197949016875157`\)\(\[InvisibleSpace]\)\
\) + 0.5`\ type$, 
        0.0584233090588386` \[LessEqual] type$ \[LessEqual] 
          0.05842331400466357`, \(\(0.519794903767076`\)\(\[InvisibleSpace]\)\
\) + 0.5`\ type$, 
        0.05842331400466357` \[LessEqual] type$ \[LessEqual] 
          0.05842331400466414`, \
\(\(0.5197949016875159`\)\(\[InvisibleSpace]\)\) + 0.5`\ type$, 
        0.05842331400466414` \[LessEqual] type$ \[LessEqual] 
          0.05938470506254181`, \(\(0.519794903767076`\)\(\[InvisibleSpace]\)\
\) + 0.5`\ type$, 
        0.05938470506254181` \[LessEqual] type$ \[LessEqual] 
          0.05938470506254717`, \
\(\(0.5197949016875159`\)\(\[InvisibleSpace]\)\) + 0.5`\ type$, 
        0.05938470506254717` \[LessEqual] type$ \[LessEqual] 
          0.05938470506254789`, \(\(0.519794903767076`\)\(\[InvisibleSpace]\)\
\) + 0.5`\ type$, 
        0.05938470506254789` \[LessEqual] type$ \[LessEqual] 
          0.05938470506255326`, \
\(\(0.5197949016875157`\)\(\[InvisibleSpace]\)\) + 0.5`\ type$, 
        0.05938470506255326` \[LessEqual] type$ \[LessEqual] 
          0.05938470714209969`, \(\(0.519794903767076`\)\(\[InvisibleSpace]\)\
\) + 0.5`\ type$, 
        0.05938470714209969` \[LessEqual] type$ \[LessEqual] 
          0.059384707142106044`, \(\(0.5197949016875157`\)\(\[InvisibleSpace]\
\)\) + 0.5`\ type$, 
        0.059384707142106044` \[LessEqual] type$ \[LessEqual] 
          0.059384707142106766`, \
\(\(0.519794903767076`\)\(\[InvisibleSpace]\)\) + 0.5`\ type$, 
        0.059384707142106766` \[LessEqual] type$ \[LessEqual] 
          0.059384707142111005`, \(\(0.5197949016875159`\)\(\[InvisibleSpace]\
\)\) + 0.5`\ type$, 
        0.059384707142111005` \[LessEqual] type$ \[LessEqual] 
          0.05938470714211213`, \(\(0.519794903767076`\)\(\[InvisibleSpace]\)\
\) + 0.5`\ type$, 
        0.05938470714211213` \[LessEqual] type$ \[LessEqual] 
          0.0647917917042705`, \(\(0.5197949016875157`\)\(\[InvisibleSpace]\)\
\) + 0.5`\ type$, 
        0.0647917917042705` \[LessEqual] type$ \[LessEqual] 
          0.06479179170427075`, \(\(0.519794903767076`\)\(\[InvisibleSpace]\)\
\) + 0.5`\ type$, 
        0.06479179170427075` \[LessEqual] type$ \[LessEqual] 
          0.5659202312684658`, \(\(0.5197949016875159`\)\(\[InvisibleSpace]\)\
\) + 0.5`\ type$, 
        0.5659202312684658` \[LessEqual] type$ \[LessEqual] 
          0.5659830014659317`, 0.802786404500042`, 
        0.5659830014659317` \[LessEqual] type$ \[LessEqual] 
          0.5659830014659324`, \(\(0.5197949037670762`\)\(\[InvisibleSpace]\)\
\) + 0.5`\ type$, 
        0.5659830014659324` \[LessEqual] type$ \[LessEqual] 
          0.5659830056250523`, 0.802786404500042`, 
        0.5659830056250523` \[LessEqual] type$ \[LessEqual] 
          0.565983005625053`, \
\(\(0.5197949016875159`\)\(\[InvisibleSpace]\)\) + 0.5`\ type$, 
        0.565983005625053` \[LessEqual] type$ \[LessEqual] 
          0.6350813061875575`, 0.802786404500042`, 
        0.6350813061875575` \[LessEqual] type$ \[LessEqual] 
          0.6350813061875578`, \
\(\(0.48524575140626325`\)\(\[InvisibleSpace]\)\) + 0.5`\ type$, 
        0.6350813061875578` \[LessEqual] type$ \[LessEqual] 
          0.6350813061875582`, \
\(\(0.48524575140626314`\)\(\[InvisibleSpace]\)\) + 0.5`\ type$, 
        0.6350813061875582` \[LessEqual] type$ \[LessEqual] 
          0.6843847029829866`, 0.802786404500042`, 
        0.6843847029829866` \[LessEqual] type$ \[LessEqual] 
          0.684384702982987`, \
\(\(0.4605940530085486`\)\(\[InvisibleSpace]\)\) + 0.5`\ type$, 
        0.684384702982987` \[LessEqual] type$ \[LessEqual] 
          0.6843847029829873`, 0.802786404500042`, 
        0.6843847029829873` \[LessEqual] type$ \[LessEqual] 
          0.6843847029829877`, \(\(0.4605940530085486`\)\(\[InvisibleSpace]\)\
\) + 0.5`\ type$, 
        0.6843847029829877` \[LessEqual] type$ \[LessEqual] 
          0.6843847029829876`, 0.802786404500042`, 
        0.6843847029829876` \[LessEqual] type$ \[LessEqual] 
          0.6843847029829875`, \(\(0.4605940530085486`\)\(\[InvisibleSpace]\)\
\) + 0.5`\ type$, 
        0.6843847029829875` \[LessEqual] type$ \[LessEqual] 
          0.6843847050625471`, 0.802786404500042`, 
        0.6843847050625471` \[LessEqual] type$ \[LessEqual] 
          0.6843847050625473`, \
\(\(0.46059405196876846`\)\(\[InvisibleSpace]\)\) + 0.5`\ type$, 
        0.6843847050625473` \[LessEqual] type$ \[LessEqual] 
          0.6843847050625478`, \
\(\(0.46059405196876835`\)\(\[InvisibleSpace]\)\) + 0.5`\ type$, 
        0.6843847050625478` \[LessEqual] type$ \[LessEqual] 
          0.684384705062548`, \(\(0.46059405196876846`\)\(\[InvisibleSpace]\)\
\) + 0.5`\ type$, 
        0.684384705062548` \[LessEqual] type$ \[LessEqual] 
          0.6843847050625483`, \
\(\(0.46059405196876835`\)\(\[InvisibleSpace]\)\) + 0.5`\ type$, 
        0.6843847050625483` \[LessEqual] type$ \[LessEqual] 
          0.6855668183384991`, 0.802786404500042`, 
        0.6855668183384991` \[LessEqual] type$ \[LessEqual] 
          0.6855668183384996`, 0.8027864045000422`, 
        0.6855668183384996` \[LessEqual] type$ \[LessEqual] 
          0.6855668190372696`, 0.802786404500042`, 
        0.6855668190372696` \[LessEqual] type$ \[LessEqual] 
          0.6855668190372698`, 0.8027864045000422`, 
        0.6855668190372698` \[LessEqual] type$ \[LessEqual] 
          0.6855668344913192`, 0.802786404500042`, 
        0.6855668344913192` \[LessEqual] type$ \[LessEqual] 
          0.6855668344913195`, 0.8027864045000422`, 
        0.6855668344913195` \[LessEqual] type$ \[LessEqual] 
          0.6855668351900917`, 0.802786404500042`, 
        0.6855668351900917` \[LessEqual] type$ \[LessEqual] 
          0.6855668351900919`, 0.8027864045000422`, 
        0.6855668351900919` \[LessEqual] type$ \[LessEqual] 0.6875`, 
        0.802786404500042`, 
        0.6875` \[LessEqual] type$ \[LessEqual] 0.6905022993270007`, 
        0.8027864045000422`, 
        0.6905022993270007` \[LessEqual] type$ \[LessEqual] 
          0.6905022993270009`, 0.802786404500042`, 
        0.6905022993270009` \[LessEqual] type$ \[LessEqual] 
          0.6905023047569319`, 0.8027864045000422`, 
        0.6905023047569319` \[LessEqual] type$ \[LessEqual] 
          0.6905023047569318`, 0.802786404500042`, 
        0.6905023047569318` \[LessEqual] type$ \[LessEqual] 
          0.6905023047569322`, 0.8027864045000422`, 
        0.6905023047569322` \[LessEqual] type$ \[LessEqual] 
          0.6905023047569321`, 0.802786404500042`, 
        0.6905023047569321` \[LessEqual] type$ \[LessEqual] 
          0.6905023047569331`, 0.8027864045000422`, 
        0.6905023047569331` \[LessEqual] type$ \[LessEqual] 
          0.6905023073316188`, 0.802786404500042`, 
        0.6905023073316188` \[LessEqual] type$ \[LessEqual] 
          0.6905023073316201`, 0.8027864045000422`, 
        0.6905023073316201` \[LessEqual] type$ \[LessEqual] 
          0.69050230733162`, 0.802786404500042`, 
        0.69050230733162` \[LessEqual] type$ \[LessEqual] 
          0.6905023127615504`, 0.8027864045000422`, 
        0.6905023127615504` \[LessEqual] type$ \[LessEqual] 
          0.6905023127615507`, 0.802786404500042`, 
        0.6905023127615507` \[LessEqual] type$ \[LessEqual] 
          0.6920676079781478`, 0.8027864045000422`, 
        0.6920676079781478` \[LessEqual] type$ \[LessEqual] 
          0.692067607978148`, 0.802786404500042`, 
        0.692067607978148` \[LessEqual] type$ \[LessEqual] 
          0.6920676079781483`, 0.8027864045000422`, 
        0.6920676079781483` \[LessEqual] type$ \[LessEqual] 
          0.6920676110555142`, 0.802786404500042`, 
        0.6920676110555142` \[LessEqual] type$ \[LessEqual] 
          0.6920676110555141`, 0.8027864045000422`, 
        0.6920676110555141` \[LessEqual] type$ \[LessEqual] 
          0.6920676110555146`, 0.802786404500042`, 
        0.6920676110555146` \[LessEqual] type$ \[LessEqual] 
          0.692067611055515`, 0.8027864045000422`, 
        0.692067611055515` \[LessEqual] type$ \[LessEqual] 
          0.6920676110555154`, 0.802786404500042`, 
        0.6920676110555154` \[LessEqual] type$ \[LessEqual] 
          0.6920676124943544`, 0.8027864045000422`, 
        0.6920676124943544` \[LessEqual] type$ \[LessEqual] 
          0.6920676124943548`, 0.802786404500042`, 
        0.6920676124943548` \[LessEqual] type$ \[LessEqual] 
          0.692067612494355`, 0.8027864045000422`, 
        0.692067612494355` \[LessEqual] type$ \[LessEqual] 
          0.6920676152146347`, 0.802786404500042`, 
        0.6920676152146347` \[LessEqual] type$ \[LessEqual] 
          0.6920676152146352`, 0.8027864045000422`, 
        0.6920676152146352` \[LessEqual] type$ \[LessEqual] 
          0.6920676152146354`, 0.802786404500042`, 
        0.6920676152146354` \[LessEqual] type$ \[LessEqual] 
          0.6920676155717216`, 0.8027864045000422`, 
        0.6920676155717216` \[LessEqual] type$ \[LessEqual] 
          0.6920676182920014`, 0.802786404500042`, 
        0.6920676182920014` \[LessEqual] type$ \[LessEqual] 
          0.6920676182920025`, 0.8027864045000422`, 
        0.6920676182920025` \[LessEqual] type$ \[LessEqual] 
          0.6920676182920024`, 0.802786404500042`, 
        0.6920676182920024` \[LessEqual] type$ \[LessEqual] 
          0.6920676197308426`, 0.8027864045000422`, 
        0.6920676197308426` \[LessEqual] type$ \[LessEqual] 
          0.6920676197308425`, 0.802786404500042`, 
        0.6920676197308425` \[LessEqual] type$ \[LessEqual] 
          0.7527183434913198`, 0.8027864045000422`, 
        0.7527183434913198` \[LessEqual] type$ \[LessEqual] 
          0.9704915028125267`, \
\(\(0.48524575140626314`\)\(\[InvisibleSpace]\)\) + 0.5`\ type$, 
        0.9704915028125267` \[LessEqual] type$ \[LessEqual] 1, 
        0.9704915028125263`]]\)], "Output"]
}, Open  ]],

Cell[CellGroupData[{

Cell[BoxData[
    \(ToDate[AbsoluteTime[]]\)], "Input"],

Cell[BoxData[
    \({2001, 4, 11, 15, 42, 22.`7.363}\)], "Output"]
}, Open  ]]
}, Open  ]],

Cell[BoxData[
    \(bestResponse[%92]\)], "Input"],

Cell[BoxData[
    \(ToDate[AbsoluteTime[]]\)], "Input"],

Cell[BoxData[
    \(\(\( (*\ Off[$MaxExtraPrecision::"\<meprec\>"]\ *) \)\(\ \)\( (*\ 
      TODO\ why\ does\ it\ complain\ about\ \(\(this\)\(?\)\)\ *) \)\)\)], \
"Input"]
},
FrontEndVersion->"4.1 for X",
ScreenRectangle->{{0, 1600}, {0, 1200}},
CellGrouping->Manual,
WindowSize->{833, 1179},
WindowMargins->{{159, Automatic}, {0, Automatic}},
PrintingCopies->1,
PrintingPageRange->{Automatic, Automatic}
]

(*******************************************************************
Cached data follows.  If you edit this Notebook file directly, not
using Mathematica, you must remove the line containing CacheID at
the top of  the file.  The cache data will then be recreated when
you save this file from within Mathematica.
*******************************************************************)

(*CellTagsOutline
CellTagsIndex->{}
*)

(*CellTagsIndex
CellTagsIndex->{}
*)

(*NotebookFileOutline
Notebook[{
Cell[1705, 50, 305, 6, 65, "Text"],

Cell[CellGroupData[{
Cell[2035, 60, 42, 0, 58, "Section"],
Cell[2080, 62, 431, 7, 75, "Input"],
Cell[2514, 71, 50, 1, 27, "Input"],

Cell[CellGroupData[{
Cell[2589, 76, 60, 0, 44, "Subsection"],
Cell[2652, 78, 315, 6, 91, "Input"],
Cell[2970, 86, 174, 3, 27, "Input"]
}, Open  ]],

Cell[CellGroupData[{
Cell[3181, 94, 58, 0, 44, "Subsection"],
Cell[3242, 96, 374, 7, 107, "Input"]
}, Open  ]],

Cell[CellGroupData[{
Cell[3653, 108, 79, 0, 44, "Subsection"],
Cell[3735, 110, 418, 7, 75, "Input"],
Cell[4156, 119, 347, 7, 59, "Input"]
}, Open  ]]
}, Open  ]],

Cell[CellGroupData[{
Cell[4552, 132, 28, 0, 58, "Section"],

Cell[CellGroupData[{
Cell[4605, 136, 102, 2, 44, "Subsection"],
Cell[4710, 140, 513, 10, 91, "Input"],
Cell[5226, 152, 413, 7, 91, "Input"],
Cell[5642, 161, 711, 13, 123, "Input"],
Cell[6356, 176, 255, 4, 43, "Input"],
Cell[6614, 182, 191, 3, 43, "Input"],
Cell[6808, 187, 489, 9, 91, "Input"]
}, Open  ]],
Cell[7312, 199, 303, 5, 59, "Input"],
Cell[7618, 206, 301, 6, 59, "Input"],
Cell[7922, 214, 447, 7, 91, "Input"],
Cell[8372, 223, 900, 15, 139, "Input"],
Cell[9275, 240, 372, 6, 75, "Input"],
Cell[9650, 248, 299, 4, 59, "Input"],
Cell[9952, 254, 848, 14, 155, "Input"],
Cell[10803, 270, 366, 6, 75, "Input"],
Cell[11172, 278, 1170, 19, 283, "Input"],
Cell[12345, 299, 641, 11, 123, "Input"],
Cell[12989, 312, 1494, 22, 267, "Input"],
Cell[14486, 336, 502, 8, 107, "Input"],
Cell[14991, 346, 613, 10, 123, "Input"],
Cell[15607, 358, 680, 13, 123, "Input"],
Cell[16290, 373, 613, 9, 123, "Input"],
Cell[16906, 384, 454, 9, 91, "Input"],
Cell[17363, 395, 1402, 25, 315, "Input"],
Cell[18768, 422, 3684, 60, 683, "Input"],
Cell[22455, 484, 814, 14, 155, "Input"],
Cell[23272, 500, 68, 1, 27, "Input"],
Cell[23343, 503, 652, 11, 139, "Input"],
Cell[23998, 516, 166, 3, 27, "Input"],
Cell[24167, 521, 153, 2, 27, "Input"],
Cell[24323, 525, 1791, 31, 315, "Input"],
Cell[26117, 558, 428, 8, 91, "Input"]
}, Open  ]],

Cell[CellGroupData[{
Cell[26582, 571, 26, 0, 58, "Section"],
Cell[26611, 573, 938, 19, 107, "Input"],
Cell[27552, 594, 60, 1, 33, "Input"],
Cell[27615, 597, 43, 1, 27, "Input"],

Cell[CellGroupData[{
Cell[27683, 602, 64, 1, 27, "Input"],
Cell[27750, 605, 290, 6, 23, "Print"],
Cell[28043, 613, 77, 1, 23, "Print"],
Cell[28123, 616, 275, 5, 23, "Print"],
Cell[28401, 623, 324, 7, 23, "Print"],
Cell[28728, 632, 275, 5, 23, "Print"],
Cell[29006, 639, 87, 2, 23, "Print"],
Cell[29096, 643, 97, 2, 23, "Print"],
Cell[29196, 647, 238, 4, 23, "Print"],
Cell[29437, 653, 298, 6, 54, "Output"]
}, Open  ]],

Cell[CellGroupData[{
Cell[29772, 664, 64, 1, 27, "Input"],
Cell[29839, 667, 290, 6, 23, "Print"],
Cell[30132, 675, 342, 7, 23, "Print"],
Cell[30477, 684, 275, 5, 23, "Print"],
Cell[30755, 691, 322, 7, 23, "Print"],
Cell[31080, 700, 273, 5, 23, "Print"],
Cell[31356, 707, 99, 2, 23, "Print"],
Cell[31458, 711, 97, 2, 23, "Print"],
Cell[31558, 715, 238, 4, 23, "Print"],
Cell[31799, 721, 236, 4, 23, "Print"],
Cell[32038, 727, 2409, 44, 87, "Print"],
Cell[34450, 773, 304, 6, 27, "Output"]
}, Open  ]],

Cell[CellGroupData[{
Cell[34791, 784, 63, 1, 27, "Input"],
Cell[34857, 787, 290, 6, 23, "Print"],
Cell[35150, 795, 344, 7, 23, "Print"],
Cell[35497, 804, 284, 6, 23, "Print"],
Cell[35784, 812, 326, 7, 23, "Print"],
Cell[36113, 821, 284, 6, 23, "Print"],
Cell[36400, 829, 99, 2, 23, "Print"],
Cell[36502, 833, 97, 2, 23, "Print"],
Cell[36602, 837, 240, 4, 23, "Print"],
Cell[36845, 843, 238, 4, 23, "Print"],
Cell[37086, 849, 355, 7, 23, "Print"],
Cell[37444, 858, 355, 7, 23, "Print"],
Cell[37802, 867, 357, 7, 23, "Print"],
Cell[38162, 876, 712, 14, 59, "Output"]
}, Open  ]],

Cell[CellGroupData[{
Cell[38911, 895, 48, 1, 27, "Input"],
Cell[38962, 898, 292, 6, 23, "Print"],
Cell[39257, 906, 348, 7, 23, "Print"],
Cell[39608, 915, 288, 6, 23, "Print"],
Cell[39899, 923, 328, 7, 23, "Print"],
Cell[40230, 932, 288, 6, 23, "Print"],
Cell[40521, 940, 99, 2, 23, "Print"],
Cell[40623, 944, 175, 3, 39, "Message"],
Cell[40801, 949, 175, 3, 39, "Message"],
Cell[40979, 954, 175, 3, 39, "Message"],
Cell[41157, 959, 163, 3, 23, "Message"],
Cell[41323, 964, 97, 2, 23, "Print"],
Cell[41423, 968, 251, 5, 23, "Print"],
Cell[41677, 975, 249, 5, 23, "Print"],
Cell[41929, 982, 351, 7, 23, "Print"],
Cell[42283, 991, 353, 7, 23, "Print"],
Cell[42639, 1000, 353, 7, 23, "Print"],
Cell[42995, 1009, 355, 7, 23, "Print"],
Cell[43353, 1018, 357, 7, 23, "Print"],
Cell[43713, 1027, 363, 7, 23, "Print"],
Cell[44079, 1036, 355, 7, 23, "Print"],
Cell[44437, 1045, 359, 7, 23, "Print"],
Cell[44799, 1054, 365, 7, 23, "Print"],
Cell[45167, 1063, 355, 7, 23, "Print"],
Cell[45525, 1072, 363, 7, 23, "Print"],
Cell[45891, 1081, 357, 7, 23, "Print"],
Cell[46251, 1090, 361, 7, 23, "Print"],
Cell[46615, 1099, 359, 7, 23, "Print"],
Cell[46977, 1108, 18633, 344, 1019, "Output"]
}, Open  ]],

Cell[CellGroupData[{
Cell[65647, 1457, 55, 1, 27, "Input"],
Cell[65705, 1460, 66, 1, 27, "Output"]
}, Open  ]]
}, Open  ]],
Cell[65798, 1465, 50, 1, 27, "Input"],
Cell[65851, 1468, 55, 1, 27, "Input"],
Cell[65909, 1471, 172, 3, 27, "Input"]
}
]
*)



(*******************************************************************
End of Mathematica Notebook file.
*******************************************************************)