(***********************************************************************
Mathematica-Compatible Notebook
This notebook can be used on any computer system with Mathematica 3.0,
MathReader 3.0, or any compatible application. The data for the notebook
starts with the line of 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[ 21737, 578]*)
(*NotebookOutlinePosition[ 22820, 615]*)
(* CellTagsIndexPosition[ 22776, 611]*)
(*WindowFrame->Normal*)
Notebook[{
Cell[CellGroupData[{Cell[TextData[
"Rearrangement Of Polynomials Using\nSearch Algorithms"], "Title",
Evaluatable->False,
AspectRatioFixed->True],
Cell[CellGroupData[{Cell[TextData["Introduction"], "Section",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[
"Polynomials can be rearranged in a certain way so that the form obtained by \
the manipulation could match some desired form. One such rearrangement is \
assigning the multiplications in the polynomial to have some units of cost by \
some factor higher than the units of cost assigned to the additions in the \
polynomial. This way the optimal form in terms of cost would be Horner's \
form which would then have the least number of multiplications. "], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[
"An nth order polynomial in its standard form has its structure such that the \
number of the multiplications are maximized. As the assigned cost of the \
multiplication was five times as much as the cost of the addition, the \
original structure of the polynomial had to be altered in such a way that the \
resulting form would mathematically be equivalent but at the same \ntime, \
the form would be such that the number of multiplications in the polynomial \
get minimized. To accomplish the task, four search algorithms were used. \
The algorithms used were divided into two classes: informed and the \
uninformed search algorithms. The uninformed search algorithms have no \
available information to guess the location of the goal state and thus have \
to go exhaustively through the search tree. However, they can identify the \
goal state if they ever reach it. Search algorithms generate the new \
successor states using legal operations on the current state. The two \
uninformed search algorithms used include breadth first search and the depth \
first search. The informed search algorithms on the other hand include some \
sort of heuristic to help the navigation to the goal state. The two \
informed search algorithms used were hill climbing and simulated annealing. \
"], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[
"The following polynomial will be used throughout the book to illustrate \
the working of the search algorithms "], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell[CellGroupData[{Cell[TextData[
"polynomiallocal = A x + B x^2 + C x^3 + D x^4 + E x^5\n"], "Input",
InitializationCell->True,
AspectRatioFixed->True],
Cell[OutputFormData["\<\
A*x + B*x^2 + C*x^3 + D*x^4 + E*x^5\
\>",
"\<\
2 3 4 5
A x + B x + C x + D x + E x\
\>"], "Output",
Evaluatable->False,
AspectRatioFixed->True]}, Open]]}, Open]],
Cell[CellGroupData[{Cell[TextData["Background"], "Section",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[
"All the algorithms require a successor function to be passed in. If one is \
not passed in, then the default successor function will be used which also \
requires the rules to be passed in to be used by the default successor \
function. An evaluation function specific to the problem should be passed in \
otherwise the default evaluation function will be processed which is simply \
the number of leaves in the mathematical expression. "], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[
"If the uninformed search algorithms are used, then the factor by which the \
cost has to be reduced should be passed in so that the goal state could be \
determined. "], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[
"If the simulated annealing is used then the cooling schedule along with the \
maximum number of iterations should be provided. If they are not passed in, \
then the default cooling schedule along with the default number of iterations \
equal to twenty will be used by the algorithm. The exact names of the \
parameters can be determined by the usage statements. The examples of running \
along with some results are shown below the captions \"Example\". \t"], "Text",\
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[
"The following statement will load all the required packages required to run \
the algorithms. "], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData["Needs[ \"HeuristicSearch`Master`\" ]"], "Input",
InitializationCell->True,
AspectRatioFixed->True],
Cell[TextData[
"The following section will provide some insight into the working of the four \
search algorithms. Discussion of informed search algorithms will follow the \
discussion of uninformed search algorithms. "], "Text",
Evaluatable->False,
AspectRatioFixed->True]}, Open]],
Cell[CellGroupData[{Cell[TextData["Breadth First Search"], "Section",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[
"The breadth first search goes through the search tree and makes a list of \
nodes to be explored. Each time a node is plucked out of the list of nodes \
from the front. The node is checked to see if it is the goal state. If the \
plucked up node is the goal state, then the search stops and provides the \
node as the result. If the node is not the goal state, then its successors \
are found using the successor function. The successors of the node are then \
appended at the end of the list of nodes to be explored. In this way, the \
search goes breadth wise through the tree and explores the tree in the row \
wise fashion starting from the given problem."], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[
"The time complexity of the search technique is exponential. This is because \
for each new node, the algorithm generates a new set of successors to be \
evaluated."], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[
"The memory requirement of the algorithm is also exponential because the \
algorithm has to store all the nodes to be explored in the memory. "], "Text",\
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[
"However, it should be noted that the algorithm is complete. "], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell[CellGroupData[{Cell[TextData["Examples"], "Subsection",
Evaluatable->False,
AspectRatioFixed->True],
Cell[CellGroupData[{Cell[TextData[
"BreadthFirstSearch[polynomiallocal, \n EvaluationFunction \
-> InitEvalPoly,\n SuccessorFunction -> \
PolySuccessorFunction,\n CostReductionFactor -> 1.5 ] "],
"Input",
AspectRatioFixed->True],
Cell[OutputFormData["\<\
A*x + x^2*(B + C*x) + x^4*(D + E*x)\
\>",
"\<\
2 4
A x + x (B + C x) + x (D + E x)\
\>"], "Output",
Evaluatable->False,
AspectRatioFixed->True]}, Open]],
Cell[CellGroupData[{Cell[TextData[
"BreadthFirstSearch[polynomiallocal, \n EvaluationFunction \
-> InitEvalPoly,\n SuccessorFunction -> \
PolySuccessorFunction,\n CostReductionFactor -> 2 ]\n"],
"Input",
AspectRatioFixed->True],
Cell[OutputFormData["\<\
x*(A + B*x) + x^3*(C + x*(D + E*x))\
\>",
"\<\
3
x (A + B x) + x (C + x (D + E x))\
\>"], "Output",
Evaluatable->False,
AspectRatioFixed->True]}, Open]],
Cell[TextData[{
StyleBox["\nNote: ",
Evaluatable->False,
AspectRatioFixed->True,
FontColor->RGBColor[1, 0, 0]],
StyleBox[
"The cost has been reduced by the factor of 1.5 and 2 \nrespectively.",
Evaluatable->False,
AspectRatioFixed->True]
}], "Text",
Evaluatable->False,
AspectRatioFixed->True]}, Open]]}, Open]],
Cell[CellGroupData[{Cell[TextData["Depth First Search"], "Section",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[
"This algorithm differs from the breadth first search in the manner that it \
appends the newly explored nodes at the beginning of the list of nodes to be \
explored. In that way, the first successor of the newly explored node is \
explored next. Thus the search algorithm goes straight down the tree to look \
for the goal state. Once it reaches the leaf of the tree, it backs off and \
goes to the next successor in the last explored set of the successors. "],
"Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[
"The time complexity of the depth first search is same as the breadth first \
search in the worst case, because in the worst case, both of the search \
algorithms will have to go through the whole tree. The user can explore this \
fact by the running the two algorithms in the tree without a goal. This \
situation can be handled by varying the parameter associated with the goal \
function. "], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[
"It should be noted that the space complexity of the algorithm is linear. \
However, the depth first search technique outperforms the breadth first \
search in the tree structures where there are many goal states. The other \
situation where the depth first search might outperform the breadth first \
search is when the goal state is situated in deepest of the layers of a tree. \
This situation is very similar to the situation encountered in the case of \
polynomials where more factored form is preferred over the less factored \
form. That is the reason why the depth first search performs much better than \
the breadth first search in the present case."], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell[CellGroupData[{Cell[TextData["Examples"], "Subsection",
Evaluatable->False,
AspectRatioFixed->True],
Cell[CellGroupData[{Cell[TextData[
"DepthFirstSearch[polynomiallocal, \n EvaluationFunction -> \
InitEvalPoly,\n SuccessorFunction -> PolySuccessorFunction,\n \
CostReductionFactor -> 1.5 ]\n"], "Input",
AspectRatioFixed->True],
Cell[OutputFormData["\<\
x*(A + B*x + E*x^4 + x^2*(C + D*x))\
\>",
"\<\
4 2
x (A + B x + E x + x (C + D x))\
\>"], "Output",
Evaluatable->False,
AspectRatioFixed->True]}, Open]],
Cell[CellGroupData[{Cell[TextData[
"DepthFirstSearch[polynomiallocal, \n EvaluationFunction -> \
InitEvalPoly,\n SuccessorFunction -> PolySuccessorFunction,\n \
CostReductionFactor -> 2 ]\n"], "Input",
AspectRatioFixed->True],
Cell[OutputFormData["\<\
x*(A + B*x + x^2*(C + D*x + E*x^2))\
\>",
"\<\
2 2
x (A + B x + x (C + D x + E x ))\
\>"], "Output",
Evaluatable->False,
AspectRatioFixed->True]}, Open]],
Cell[TextData[{
StyleBox["\nNote:",
Evaluatable->False,
AspectRatioFixed->True,
FontColor->RGBColor[1, 0, 0]],
StyleBox[
" The reduction in cost by the same factor is achieved the depth first \
search. ",
Evaluatable->False,
AspectRatioFixed->True]
}], "Text",
Evaluatable->False,
AspectRatioFixed->True]}, Open]]}, Open]],
Cell[CellGroupData[{Cell[TextData["Hill Climbing"], "Section",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[
"This is the search strategy that uses heuristic which in the present case is \
also the evaluation function. The evaluation function tells which state of \
the successor states is the one with minimum cost. The algorithm works as \
follows. It first takes the problem as the current state and finds the next \
one by taking the smallest cost state of the newly generated successor \
states. If the cost of the next state found by the above method is less than \
the cost of the current state, the current state is assigned the next state \
and the search goes on. If the next state has the cost greater than the cost \
of the current state, the search is stopped and the current node is returned \
as the result. "], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[
"In the case of the polynomials, the hill climbing search outperforms other \
search strategies because of the way successor states are generated. Since \
all the newly generated states are further factored, the next state cannot \
have the cost greater than the current state. Also in this way, the \
algorithm does not have any local maximas to get stuck on and provides the \
form where the rule can no longer be applied on the resultant state. This \
method thus give the optimal form for the rule devised to reach the solution \
for the problem. It should however be noted that this optimal form is for \
the rule used in this context and could be drastically different for some \
other rule. Also if some other rule is used, there is a possibility that the \
algorithm might encounter the local maximas. This would happen if the new \
rule expands some terms in the polynomial before it gets to the form where \
the structure would be such that the cost could be minimized."], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell[CellGroupData[{Cell[TextData["Examples\n"], "Subsection",
Evaluatable->False,
AspectRatioFixed->True],
Cell[CellGroupData[{Cell[TextData[
"HillClimbing[polynomiallocal, \n EvaluationFunction -> \
InitEvalPoly,\n SuccessorFunction -> PolySuccessorFunction]\n"],
"Input",
AspectRatioFixed->True],
Cell[OutputFormData["\<\
{{x*(A + x*(B + x*(C + x*(D + E*x))))}}\
\>",
"\<\
{{x (A + x (B + x (C + x (D + E x))))}}\
\>"], "Output",
Evaluatable->False,
AspectRatioFixed->True]}, Open]],
Cell[TextData[{
StyleBox["\nNote:",
Evaluatable->False,
AspectRatioFixed->True,
FontColor->RGBColor[1, 0, 0]],
StyleBox[
" The optimal form has been achieved using the hill climbing algorithm.",
Evaluatable->False,
AspectRatioFixed->True]
}], "Text",
Evaluatable->False,
AspectRatioFixed->True]}, Open]]}, Open]],
Cell[CellGroupData[{Cell[TextData["Simulated Annealing"], "Section",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[
"Simulated annealing is the second algorithm used in this context which uses \
a heuristic for an intelligent search. Instead of starting again randomly \
when stuck on a local maximum, the algorithm allows some downhill steps to \
escape the local maximum. The innermost loop of the simulated annealing is \
quite similar to hill climbing. Instead of picking the best move, however, \
it picks a random move. If the move actually improves the situation, it is \
always executed. Otherwise, the algorithm makes the move with some \
probability less than one. The probability decreases exponentially with the \
\"badness\" of the move by the amount deltaE by which the evaluation is \
worsened.\n\nA second parameter temperature is also used to determine the \
probability. At higher values of temperature, \"bad\" moves are more likely \
to be allowed. A temperature tends to zero, they become more and more \
unlikely, until the algorithm behaves more or less like hill climbing. The \
schedule input determines the value of temperature as a function of how many \
cycles already have been completed. The algorithm was developed from an \
explicit analogy with annealing-the process of gradually cooling a liquid \
until it freezes. The evaluation function corresponds to the total energy of \
the atoms in the material. Schedule determines the rate at which the \
temperature is lowered. Individual moves in the state space correspond to \
random fluctuations due to thermal noise. One can prove that if the \
temperature is lowered sufficiently slowly, the material will attain a \
lowest-energy (perfectly) ordered configuration.This corresponds to the \
statement that if the schedule lowers the temperature slowly enough, the \
algorithm will find a global optimum."], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell[CellGroupData[{Cell[TextData["Examples"], "Subsection",
Evaluatable->False,
AspectRatioFixed->True],
Cell[CellGroupData[{Cell[TextData[
"SimulatedAnnealing[polynomiallocal, \n EvaluationFunction \
-> InitEvalPoly,\n SuccessorFunction -> \
PolySuccessorFunction,\n MaxIterations -> 100]\n\n"],
"Input",
AspectRatioFixed->True],
Cell[OutputFormData["\<\
{x*(A + D*x^3 + x*(B + x*(C + E*x^2)))}\
\>",
"\<\
3 2
{x (A + D x + x (B + x (C + E x )))}\
\>"], "Output",
Evaluatable->False,
AspectRatioFixed->True]}, Open]],
Cell[CellGroupData[{Cell[TextData[
"SimulatedAnnealing[polynomiallocal, \n EvaluationFunction \
-> InitEvalPoly,\n SuccessorFunction -> \
PolySuccessorFunction,\n MaxIterations -> 500]"], "Input",
AspectRatioFixed->True],
Cell[OutputFormData["\<\
{x*(A + D*x^3 + x*(B + x*(C + E*x^2)))}\
\>",
"\<\
3 2
{x (A + D x + x (B + x (C + E x )))}\
\>"], "Output",
Evaluatable->False,
AspectRatioFixed->True]}, Open]],
Cell[TextData[
"Note: Not a quite optimal form has been achieved because the default cooling \
function does not cool slowly enough."], "Text",
Evaluatable->False,
AspectRatioFixed->True]}, Open]]}, Open]],
Cell[CellGroupData[{Cell[TextData["Reference Manual"], "Section",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[
"The functions used by the four search algorithms which are also available \
for the public usage include following."], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[{
StyleBox["General Algorithm Usage Functions:",
Evaluatable->False,
AspectRatioFixed->True,
FontColor->RGBColor[1, 0, 0]],
StyleBox["\nThe following functions could be found in the package named ",
Evaluatable->False,
AspectRatioFixed->True],
StyleBox["\"GENERAL`GeneralSearch`\"",
Evaluatable->False,
AspectRatioFixed->True,
FontColor->RGBColor[0, 0, 1]]
}], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[StyleBox[
"DefaultEvaluationFunction\nTheSmallest\nRuleBasedSuccessorFunction\nGoalFun\n\
GoalTest",
Evaluatable->False,
AspectRatioFixed->True,
FontColor->RGBColor[0, 1, 0]]], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[{
StyleBox["Polynomial Manipulation Functions:",
Evaluatable->False,
AspectRatioFixed->True,
FontColor->RGBColor[1, 0, 0]],
StyleBox["\nThe following functions could be found in the package named\n",
Evaluatable->False,
AspectRatioFixed->True],
StyleBox["\"GENERAL`PolySearchFunctions`\"",
Evaluatable->False,
AspectRatioFixed->True,
FontColor->RGBColor[0, 0, 1]]
}], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[StyleBox["EvalPoly\nInitEvalPoly\nPolySuccessorFunction",
Evaluatable->False,
AspectRatioFixed->True,
FontColor->RGBColor[0, 1, 0]]], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[
"For the complete usage information of the functions, use "], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData["?EvalPoly"], "Input",
AspectRatioFixed->True]}, Open]],
Cell[CellGroupData[{Cell[TextData["References"], "Section",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[{
StyleBox["[1] S. Wolfram, ",
Evaluatable->False,
AspectRatioFixed->True],
StyleBox["Mathematica: A System for Doing Mathematics by Computer,",
Evaluatable->False,
AspectRatioFixed->True,
FontSlant->"Italic"],
StyleBox[" Redwood City, CA: Addison-Wesley, second ed., 1991.",
Evaluatable->False,
AspectRatioFixed->True]
}], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[{
StyleBox["[2] S. Russel and P. Norvig, ",
Evaluatable->False,
AspectRatioFixed->True],
StyleBox["Artificial Intelligence: A Modern Approach",
Evaluatable->False,
AspectRatioFixed->True,
FontSlant->"Italic"],
StyleBox[". Englewood Cliffs, NJ: Prentice Hall, 1995.\n",
Evaluatable->False,
AspectRatioFixed->True]
}], "Text",
Evaluatable->False,
AspectRatioFixed->True]}, Open]]}, Open]]
},
FrontEndVersion->"Macintosh 3.0",
ScreenRectangle->{{0, 640}, {0, 460}},
AutoGeneratedPackage->None,
WindowToolbars->{},
CellGrouping->Manual,
WindowSize->{520, 365},
WindowMargins->{{36, Automatic}, {30, Automatic}},
PrivateNotebookOptions->{"ColorPalette"->{RGBColor, -1}},
ShowCellLabel->True,
ShowCellTags->False,
RenderingOptions->{"ObjectDithering"->True,
"RasterDithering"->False},
MacintoshSystemPageSetup->"\<\
AVU/IFiQKFD000000W7D@09ag@0000000O=J`09FV"
]
(***********************************************************************
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[CellGroupData[{
Cell[1731, 51, 129, 3, 70, "Title",
Evaluatable->False],
Cell[CellGroupData[{
Cell[1883, 56, 89, 2, 70, "Section",
Evaluatable->False],
Cell[1975, 60, 527, 8, 70, "Text",
Evaluatable->False],
Cell[2505, 70, 1376, 20, 70, "Text",
Evaluatable->False],
Cell[3884, 92, 188, 4, 70, "Text",
Evaluatable->False],
Cell[CellGroupData[{
Cell[4095, 98, 137, 3, 70, "Input",
InitializationCell->True],
Cell[4235, 103, 200, 8, 70, "Output",
Evaluatable->False]
}, Open ]]
}, Open ]],
Cell[CellGroupData[{
Cell[4476, 113, 87, 2, 70, "Section",
Evaluatable->False],
Cell[4566, 117, 517, 8, 70, "Text",
Evaluatable->False],
Cell[5086, 127, 241, 5, 70, "Text",
Evaluatable->False],
Cell[5330, 134, 533, 9, 70, "Text",
Evaluatable->False],
Cell[5866, 145, 169, 4, 70, "Text",
Evaluatable->False],
Cell[6038, 151, 117, 2, 70, "Input",
InitializationCell->True],
Cell[6158, 155, 277, 5, 70, "Text",
Evaluatable->False]
}, Open ]],
Cell[CellGroupData[{
Cell[6467, 162, 97, 2, 70, "Section",
Evaluatable->False],
Cell[6567, 166, 738, 11, 70, "Text",
Evaluatable->False],
Cell[7308, 179, 238, 5, 70, "Text",
Evaluatable->False],
Cell[7549, 186, 218, 5, 70, "Text",
Evaluatable->False],
Cell[7770, 193, 135, 3, 70, "Text",
Evaluatable->False],
Cell[CellGroupData[{
Cell[7928, 198, 88, 2, 70, "Subsection",
Evaluatable->False],
Cell[CellGroupData[{
Cell[8039, 202, 267, 5, 70, "Input"],
Cell[8309, 209, 195, 8, 70, "Output",
Evaluatable->False]
}, Open ]],
Cell[CellGroupData[{
Cell[8536, 219, 266, 5, 70, "Input"],
Cell[8805, 226, 189, 8, 70, "Output",
Evaluatable->False]
}, Open ]],
Cell[9006, 236, 326, 11, 70, "Text",
Evaluatable->False]
}, Open ]]
}, Open ]],
Cell[CellGroupData[{
Cell[9373, 249, 95, 2, 70, "Section",
Evaluatable->False],
Cell[9471, 253, 536, 9, 70, "Text",
Evaluatable->False],
Cell[10010, 264, 468, 8, 70, "Text",
Evaluatable->False],
Cell[10481, 274, 736, 11, 70, "Text",
Evaluatable->False],
Cell[CellGroupData[{
Cell[11240, 287, 88, 2, 70, "Subsection",
Evaluatable->False],
Cell[CellGroupData[{
Cell[11351, 291, 257, 4, 70, "Input"],
Cell[11611, 297, 194, 8, 70, "Output",
Evaluatable->False]
}, Open ]],
Cell[CellGroupData[{
Cell[11837, 307, 255, 4, 70, "Input"],
Cell[12095, 313, 203, 8, 70, "Output",
Evaluatable->False]
}, Open ]],
Cell[12310, 323, 334, 12, 70, "Text",
Evaluatable->False]
}, Open ]]
}, Open ]],
Cell[CellGroupData[{
Cell[12685, 337, 90, 2, 70, "Section",
Evaluatable->False],
Cell[12778, 341, 795, 12, 70, "Text",
Evaluatable->False],
Cell[13576, 355, 1059, 15, 70, "Text",
Evaluatable->False],
Cell[CellGroupData[{
Cell[14658, 372, 90, 2, 70, "Subsection",
Evaluatable->False],
Cell[CellGroupData[{
Cell[14771, 376, 199, 4, 70, "Input"],
Cell[14973, 382, 181, 7, 70, "Output",
Evaluatable->False]
}, Open ]],
Cell[15166, 391, 324, 11, 70, "Text",
Evaluatable->False]
}, Open ]]
}, Open ]],
Cell[CellGroupData[{
Cell[15531, 404, 96, 2, 70, "Section",
Evaluatable->False],
Cell[15630, 408, 1850, 26, 70, "Text",
Evaluatable->False],
Cell[CellGroupData[{
Cell[17503, 436, 88, 2, 70, "Subsection",
Evaluatable->False],
Cell[CellGroupData[{
Cell[17614, 440, 263, 5, 70, "Input"],
Cell[17880, 447, 213, 8, 70, "Output",
Evaluatable->False]
}, Open ]],
Cell[CellGroupData[{
Cell[18125, 457, 256, 4, 70, "Input"],
Cell[18384, 463, 213, 8, 70, "Output",
Evaluatable->False]
}, Open ]],
Cell[18609, 473, 191, 4, 70, "Text",
Evaluatable->False]
}, Open ]]
}, Open ]],
Cell[CellGroupData[{
Cell[18841, 479, 93, 2, 70, "Section",
Evaluatable->False],
Cell[18937, 483, 190, 4, 70, "Text",
Evaluatable->False],
Cell[19130, 489, 468, 14, 70, "Text",
Evaluatable->False],
Cell[19601, 505, 252, 7, 70, "Text",
Evaluatable->False],
Cell[19856, 514, 475, 14, 70, "Text",
Evaluatable->False],
Cell[20334, 530, 209, 5, 70, "Text",
Evaluatable->False],
Cell[20546, 537, 132, 3, 70, "Text",
Evaluatable->False],
Cell[20681, 542, 62, 1, 70, "Input"]
}, Open ]],
Cell[CellGroupData[{
Cell[20775, 545, 87, 2, 70, "Section",
Evaluatable->False],
Cell[20865, 549, 427, 13, 70, "Text",
Evaluatable->False],
Cell[21295, 564, 421, 13, 70, "Text",
Evaluatable->False]
}, Open ]]
}, Open ]]
}
]
*)
(***********************************************************************
End of Mathematica Notebook file.
***********************************************************************)