# Posts tagged as “Fearful Symmetry”

“I … I gotta be honest here. I needs help.” “Cinnamon,” Nri says gently. “I know that. I’ve had many, many students before.” “Another damn teacher,” I rollin’ my eyes. Then I realizes—“Did I say thatAh, Cinnamon, you and your wacky hijinks. Thanks for coming into my writing life, wherever the hell you came from. And now, on to all the things I've been putting off blogging while I've been working on Nano, including ... how to succeed at Nano! (I hope you'll agree I have some credentials in that area). Onward, fellow adventurers! -the Centaurout loud?” “Yes, you did,” Nri says, smiling sardonically. “I don’t even think that was Tourette’s.” “It-it wasn’t,” I says. “I’m sorry, sir, but …” I grimaces. I genuinely don’t know what tone to set here. Act like Mom’s world, use Southern politeness, act like the werekindred, use growls and barks … or, maybe, just be me? Who’s that then? “I, uh, don’t, ah, know how to say this but I wasn’t tryin’ to insult you before or to butter you up now but we gots a real situation and if we leaves it up to my Mom there’s a very good chance that the D of the W. A. will spirit my boyfriend and my alt-crush off to the wilds of nowhevers, and if the elders of the werehold finds out where they are they may go and do somethin’ stupid right on the doorsteps of people totally prepared to do somethin’ stupid, so I’m guessin’ the smart thing is for the people who are smart and wizardly to do somethin’ smart and wizardly, but I can’t do this alone, because I am, like, thirteen, and why in godsname does everybody think I can do everythin?” Nri stares, blinks, shakes his head, like he’s comin’ out of a trance. “God, I’d wish I’d timed that,” he says. “I think you talk faster than JFK—” “Who?” I asks. “Nevermind," Nri says. "I’m sold.”

So now things are back on track for the month, and I'm smack in the middle of where I normally am this time of Nano ... Actually, it appears I'm ahead. Checking the stats ... yep. At this point, I'm normally just shy of 6,000 words behind ( -5,984, though that estimate is numerically precise, it is not likely to be meaningfully accurate ) but today I am 169 words ahead of the Nano wordcount: I'm one more thing too: 200,000 words into the Cinnamon Frost trilogy. There are 3 published Dakota Frost novels: FROST MOON, BLOOD ROCK and LIQUID FIRE, and three more finished rough drafts: SPECTRAL IRON, PHANTOM SILVER, and SPIRITUAL GOLD. By my count, I've written about 900,000 words about Dakota Frost, Skindancer, the woman who can bring her tattoos to life. But in one sense, that's expected: I planned Dakota. I wanted to write a character that other people who can relate to. Cinnamon Frost, as I've said before, is a character I never expected. She shoved her way into the Dakota Frost universe, in one of those "step off into space moments", and she shows no signs of leaving. Cinnamon might say 200,000 seems significant because of how humans process patterns - how we love all those zeroes - but it's just a number: 2*10*10*10*10*10. But somehow, it feels right to take it this far, and I look forward to writing the next 100,000 to 150,000 words that will finish her trilogy and give her a chance to live her own literary life. Time to get back to it. -the Centaur P. S. I said milestones are coming. If you've read closely in this post, you'll realize another milestone is coming soon. Stay tuned ...It's all too easy for stories to fall in predictable ruts - but in #NaNoWriMo , when you've got to produce 50,000 words in a month, sometimes your story "goes off the rails" into territory your conscious mind never expected ... and that's gold! https://t.co/Qmtuzb1XKE

— Anthony Francis (@xenotaur) November 13, 2017

*10(ab)'''*- that's point 10, timelines A&B, variant 3 (prime prime prime). Happy writing ... -the Centaur Pictured: A few of the math/physics books I've been reading on this idea, plus the "GBC" (Goodfellow, Bengio and Courville) Deep Learning book which I'm (re)reading for work.

*-the Centaur*

**GO!**

SO, why's an urban fantasy author digging into the guts of Mathematica trying to reverse-engineer how Stephen Wolfram drew the diagrams of cellular automata in his book *A New Kind of Science*? Well, one of my favorite characters to write about is the precocious teenage weretiger Cinnamon Frost, who at first glance was a dirty little street cat until she blossomed into a mathematical genius when watered with just the right amount of motherly love. My training as a writer was in hard science fiction, so even if I'm writing about implausible fictions like teenage weretigers, I want the things that are real - like the mathematics she develops - to be right. So I'm working on a new kind of math behind the discoveries of my little fictional genius, but I'm not the youngest winner of the Hilbert Prize, so I need tools to help simulate her thought process.

And my thought process relies on visualizations, so I thought, hey, why don't I build on whatever Stephen Wolfram did in his groundbreaking tome *A New Kind of Science*, which is filled to its horse-choking brim with handsome diagrams of cellular automata, their rules, and the pictures generated by their evolution? After all, it only took him something like ten years to write the book ... how hard could it be?

**Deconstructing the Code from A New Kind of Science, Chapter 2**

Fortunately Stephen Wolfram provides at least some of the code that he used for creating the diagrams in A New Kind of Science. He's got the code available for download on the book's website, wolframscience.com, but a large subset is in the extensive endnotes for his book (which, densely printed and almost 350 pages long, could probably constitute a book in their own right). I'm going to reproduce that code here, as I assume it's short enough to fall under fair use, and for the half-dozen functions we've got here any attempt to reverse-engineer it would end up just recreating essentially the same functions with slightly different names.

Cellular automata are systems that take patterns and evolve them according to simple rules. The most basic cellular automata operate on lists of bits - strings of cells which can be "on" or "off" or alternately "live" or "dead," "true" and "false," or just "1" and "0" - and it's easiest to show off how they behave if you start with a long string of cells which are "off" with the very center cell being "on," so you can easily see how a single live cell evolves. And Wolfram's first function gives us just that, a list filled with dead cells represented by 0 with a live cell represented by 1 in its very center:

In[1]:=

CenterList[n_Integer] := ReplacePart[Table[0, {n}], 1, Ceiling[n/2]]

In[2]:=CenterList[10]Out[2]={0, 0, 0, 0, 1, 0, 0, 0, 0, 0}

One could imagine a cellular automata which updated each cell just based on its contents, but that would be really boring as each cell would be effectively independent. So Wolfram looks at what he calls "elementary automata" which update each cell based on their neighbors. Counting the cell itself, that's a row of three cells, and there are eight possible combinations of live and dead neighbors of three elements - and only two possible values that can be set for each new element, live or dead. Wolfram had a brain flash to list the eight possible combinations the same each way every time, so all you have are that list of eight values of "live" or "dead" - or 1's and 0's, and since a list of 1's and 0's is just a binary number, that enabled Wolfram to represent each elementary automata rule as a number:

In[3]:=

ElementaryRule[num_Integer] := IntegerDigits[num, 2, 8]

In[4]:=

ElementaryRule[30]

Out[4]={0, 0, 0, 1, 1, 1, 1, 0}

Once you have that number, building code to apply the rule is easy. The input data is already a string of 1's and 0's, so Wolfram's rule for updating a list of cells basically involves shifting ("rotating") the list left and right, adding up the values of these three neighbors according to base 2 notation, and then looking up the value in the rule. Wolfram created Mathematica in part to help him research cellular automata, so the code to do this is deceptively simple…

In[5]:=

CAStep[rule_List, a_List] :=

rule[[8 - (RotateLeft[a] + 2 (a + 2 RotateRight[a]))]]

... a “RotateLeft” and a “RotateRight” with some addition and multiplication to get the base 2 index into the rule. The code to apply this again and again to a list to get the history of a cellular automata over time is also simple:

In[6]:=

CAEvolveList[rule_, init_List, t_Integer] :=

NestList[CAStep[rule, #] &, init, t]

Now we're ready to create the graphics for the evolution of Wolfram's "rule 30," the very simple rule which shows highly complex and irregular behavior, a discovery which Wolfram calls "the single most surprising scientific discovery [he has] ever made." Wow. Let's spin it up for a whirl and see what we get!

In[7]:=

CAGraphics[history_List] :=

Graphics[Raster[1 - Reverse[history]], AspectRatio -> Automatic]

In[8]:=Show[CAGraphics[CAEvolveList[ElementaryRule[30], CenterList[103], 50]]]

Out[8]=

Uh - oh. The "Raster" code that Wolfram provides is the code to create the large images of cellular automata, not the sexy graphics that show the detailed evolution of the rules. And reading between the lines of Wolfram's end notes, he started his work in FrameMaker before Mathematica was ready to be his full publishing platform, with a complex build process producing the output - so there's no guarantee that clean simple Mathematica code even exists for some of those early diagrams.

Guess we'll have to create our own.

**Visualizing Cellular Automata in the Small**

The cellular automata diagrams that Wolfram uses have boxes with thin lines, rather than just a raster image with 1's and 0's represented by borderless boxes. They're particularly appealing because the lines are white between black boxes and black between white boxes, which makes the structures very easy to see. After some digging, I found that, naturally, a Mathematica function to create those box diagrams does exist, and it's called ArrayPlot, with the Mesh option set to True:

In[9]:=

ArrayPlot[Table[Mod[i + j, 2], {i, 0, 3}, {j, 0, 3}], Mesh -> True]

Out[9]=

While we could just use ArrayPlot, it' s important when developing software to encapsulate our knowledge as much as possible, so we'll create a function CAGridGraphics (following the way Wolfram named his functions) that encapsulates the knowledge of turning the Mesh option to True. If later we decide there's a better representation, we can just update CAMeshGraphics, rather than hunting down every use of ArrayPlot. This function gives us this:

In[10]:=

CAMeshGraphics[matrix_List] :=

ArrayPlot[matrix, Mesh -> True, ImageSize -> Large]

In[11]:=

CAMeshGraphics[{CenterList[10], CenterList[10]}]

Out[11]=

Now, Wolfram has these great diagrams to help visualize cellular automata rules which show the neighbors up top and the output value at bottom, with a space between them. The GraphicsGrid does what we want here, except it by its nature resizes all the graphics to fill each available box. I'm sure there's a clever way to do this, but I don't know Mathematica well enough to find it, so I'm going to go back on what I just said earlier, break out the options on ArrayPlot, and tell the boxes to be the size I want:

In[20]:=

CATransitionGraphics[rule_List] :=

GraphicsGrid[

Transpose[{Map[

ArrayPlot[{#}, Mesh -> True, ImageSize -> {20 Length[#], 20}] &, rule]}]]

That works reasonably well; here' s an example rule, where three live neighbors in a row kills the center cell :

In[21]:=

CATransitionGraphics[{{1, 1, 1}, {0}}]

Out[21]=

Now we need the pattern of digits that Wolfram uses to represent his neighbor patterns. Looking at the diagrams and sfter some digging in the code, it seems like these digits are simply listed in reverse counting order - that is, for 3 cells, we count down from 2^3 - 1 to 0, represented as binary digits.

In[22]:=

CANeighborPattern[num_Integer] :=

Table[IntegerDigits[i, 2, num], {i, 2^num - 1, 0, -1}]

In[23]:=

CANeighborPattern[3]

Out[23]={{1, 1, 1}, {1, 1, 0}, {1, 0, 1}, {1, 0, 0}, {0, 1, 1}, {0, 1, 0}, {0, 0,

1}, {0, 0, 0}}

Stay with me - that only gets us the first row of the CATransitionGraphics; to get the next row, we need to apply a rule to that pattern and take the center cell:

In[24]:=

CARuleCenterElement[rule_List, pattern_List] :=

CAStep[rule, pattern][[Floor[Length[pattern]/2]]]

In[25]:=CARuleCenterElement[ElementaryRule[30], {0, 1, 0}]

Out[25]=1

With all this, we can now generate the pattern of 1' s and 0' s that represent the transitions for a single rule:

In[26]:=

CARulePattern[rule_List] :=

Map[{#, {CARuleCenterElement[rule, #]}} &, CANeighborPattern[3]]In[27]:=

CARulePattern[ElementaryRule[30]]

Out[27]={{{1, 1, 1}, {0}}, {{1, 1, 0}, {1}}, {{1, 0, 1}, {0}}, {{1, 0, 0}, {1}}, {{0,

1, 1}, {0}}, {{0, 1, 0}, {1}}, {{0, 0, 1}, {1}}, {{0, 0, 0}, {0}}}

Now we can turn it into graphics, putting it into another GraphicsGrid, this time with a Frame.

In[28]:=

CARuleGraphics[rule_List] :=

GraphicsGrid[{Map[CATransitionGraphics[#] &, CARulePattern[rule]]},

Frame -> All]

In[29]:=CARuleGraphics[ElementaryRule[30]]

Out[29]=

At last! We' ve got the beautiful transition diagrams that Wolfram has in his book. And we want to apply it to a row with a single cell:

In[30]:=

CAMeshGraphics[{CenterList[43]}]Out[30]=

What does that look like? Well, we once again take our CAEvolveList function from before, but rather than formatting it with Raster, we format it with our CAMeshGraphics:

In[31]:=

CAMeshGraphics[CAEvolveList[ElementaryRule[30], CenterList[43], 20]]

Out[31]=

And now we' ve got all the parts of the graphics which appear in the initial diagram of this page. Just to work it out a bit further, let’s write a single function to put all the graphics together, and try it out on rule 110, the rule which Wolfram discovered could effectively simulate any possible program, making it effectively a universal computer:

In[22]:=

CAApplicationGraphics[rule_Integer, size_Integer] := Column[

{CAMeshGraphics[{CenterList[size]}],

CARuleGraphics[ElementaryRule[rule]],

CAMeshGraphics[

CAEvolveList[ElementaryRule[rule], CenterList[size],

Floor[size/2] - 1]]},

Center]In[23]:=

CAApplicationGraphics[110, 43]

Out[23]=

It doesn' t come out quite the way it did in Photoshop, but we' re getting close. Further learning of the rules of Mathematica graphics will probably help me, but that's neither here nor there. We've got a set of tools for displaying diagrams, which we can craft into what we need.

Which happens to be a non-standard number system unfolding itself into hyperbolic space, God help me.

Wish me luck.

-the Centaur

P.S. While I' m going to do a standard blogpost on this, I' m also going to try creating a Mathematica Computable Document Format (.cdf) for your perusal. Wish me luck again - it's my first one of these things.

P.P.S. I think it' s worthwhile to point out that while the tools I just built help visualize the application of a rule in the small …

In[24]:=

CAApplicationGraphics[105, 53]

Out[24]=

... the tools Wolfram built help visualize rules in the very, very large:

In[25]:=

Show[CAGraphics[CAEvolveList[ElementaryRule[105], CenterList[10003], 5000]]]Out[25]=

That's 10,000 times bigger - 100 times bigger in each direction - and Mathematica executes and displays it flawlessly.

So after a gut punch, one of the most important things to do is to take time out to recuperate.

But funny thing is, the highly effective sangria above wasn’t the thing that broke me out of my funk. When something bad happens, I try one of the following strategies to feel better:

**Take a nap.**Or just go to bed. Sleeping can sometimes reset your emotional state. When I had my big crisis of faith in the 90’s, converting from Catholicism to Episcopalianism, I slept for like a day and a half, rethinking my whole life. Of course, if you can’t fall asleep, that’s no good - I was up to 5:50AM this morning, so blech.**Take a walk.**This can also provide metaphorical distance from your problems. During my crisis of faith, I walked around my apartment complex again and again, taking an inventory of my whole life, weighing and evaluating everything I could think of. Today, when I tried the same strategy, I was snarling at the air, so blech.**Change your scene.**Talking to uninvolved humans, not connected with your dramas, really can help. I had an interview with a candidate, a technical conversation about deep learning with a TL, and, later, after my mood was lifted, another technical conversation with my waitress at Opa! about the econometrics of developing nations.

As for why that last conversation happened …

Which goes to the next item on the list ...

**Try shopping therapy.**Doesn’t work for everyone, but I’m a bookhound. I ended up going to the Stanford Bookstore to try to pick up a book on large scale machine learning (it had sold out). The books themselves weren’t the solution, but I’m getting to that - but it did involve the books in a tangential way.**Get some coffee.**The inventor of the idea of separation of powers, Montesquieu, reportedly once said “coffee renders many foolish people temporarily capable of wise actions” and I’ve found that to be true - which perhaps suggests that we should install a Starbucks in the Congress and change the structure of our political debates, but nevermind. It helped.

* You’ll note that nowhere in here is “get a drink.”* That’s a terrible idea - if you think you need a drink, you probably shouldn’t have one, as needing a drink is the road to alcoholism. For that reason, and many others, I always stop at one drink per day - period. No matter how strong the drink, it’s almost impossible for a one hundred and eighty pound male to get drunk on just one.

Having a *drink* after you feel better, on the other hand, can be a great relaxer. But how do you get to that relaxed state? Well, one thing I try is, well, trying to resolve the problem.

**Talk to the people involved. I have a theory that if you have a problem with a person and leave it alone, your emotional reaction will be frozen, even intensified over time - a theory based on my personal experience, but backed by cognitive emotional theories which say your emotions are derived from your***stance*, your relationship to the people, actions and events in the world - which doesn’t change if you don’t give yourself the chance to have new experiences with those people. Thanks to the fact that it’s the twenty-first century, this can be done via text, even when people don’t have time to talk.

But the point at which it turned wasn’t when I got a drink. It wasn’t after I took a nap, took a walk, talked to people, changed the scene, got a book on political economy, got coffee, or texted the involved parties to finalize the resolution of yesterday evening’s gut punch. It happened at very strange place, as I was drinking coffee, as I was reading, as I was texting with my friends to resolve the problem, I got sucked in to the problem that prompted me to get the book, a question I heard in an unrelated political debate from last night. As is usual in these cases, I found that the debate followed the rule of thirds: on a third of the topics, my buddy was definitively wrong, on a third, I was definitively wrong, and on the middle third, there were open unresolved questions worthy of debate. And as I started to look at those questions … I had a brainflash on how to solve them.

And then on a meta-brain-flash, as I realized what tacking the problem was doing to my mental state: **it was fixing it.**

**Do the work.**Find something you love, and cultivate the ability to throw yourself into it. If you’ve had a gut punch, you might have a bad taste in your mouth about a lot of the projects you were working on … but get your brain into a new space, and all those behavior programs will execute … and give you something new to fall (intellectually) in love with.

The particular question I was tracking - how to evaluate economic policies - is something I’m going to be working on for a while, but I can give you a flavor for it: how do you know whether a political candidate’s economic policies will work? Sometimes that’s easy: for example, Democrats like to spend when the economy’s doing well, and Republicans like to cut when the economy is doing poorly - ** and both sides are dead wrong**. An economy is not a household - cutting spending in a slump will cut the state’s tax revenues and cause an austerity spiral and increased debt; spending in a boom incurs obligations that the state can’t sustain in the next slump and increased risk. These are pretty close to ironclad laws, that operate whether you believe in big government or small or low taxes or high; those are just the dynamics of economies whether you like it or not - whether you believe it or not, suck it up.

But looking long term, some policies promote growth, and some don’t; and it isn’t always clear which is which. What’s worse, exogenous factors - those pesky world events like wars and plagues and wardrobe malfunctions - throw an unavoidable amount of static on top of whatever we’re trying to measure.

The book I’m reading gives me, so far, the impression that individual outcomes are, roughly, helped by a country’s growth, and a country’s growth is affected by things it can't control, like the luck of history and geography, and things it can, like culture and institutions, with evidence strongly suggesting that institutions matter more than culture, since some countries have kept their cultures but changed their institutions and shown amazing growth. The factors that seem to affect this most are protecting private property, having enforceable contracts, reducing barriers for investment, having a level playing field for businesses, and creating equality of opportunity for citizens … but …

But how much of this is noise, and how much is reality?

And that got me thinking: if you assumed some randomness affecting growth, could you tell apart policies that caused 1 percent growth, or 2 percent growth, or 3 percent growth?

Turns out ... **you can.**

The central red line is 2% growth, projected out over 20 years. The dotted lines above and below it are 1% and 3% growth … and the grey range is the max and min of a stochastic simulation of ten different histories, each with 5% random variation from year to year, which looks something like this:

The point is, if you get a gut punch - like in the bottom trajectory above - it can look like you’re running a bad policy on a time range of a **decade or more** before things start to get back on track. On twenty year time horizons, however, you really can start to see an affect. On even longer time horizons, having the right polices can be the difference between a country like Nigeria - rich with oil wealth, yet having a flat growth range - versus a country like the US or Japan or even Botswana or South Korea.

This doesn’t show whether I or my buddy is right - in fact, this model, even as an abstract model, would need to be augmented greatly, to get a proper range of growth rates, of randomness, of the types of exogenous influences and their timescales. But even in its current state, it shows that under a very broad set of assumptions … I and my buddy were right to wrestle over this problem.

What we do now matters, not just in the next election, but twenty years down the road.

And doing that work took me out of my slump. It connected me to an earlier conversation, to earlier problem solving skills not engaged with what I’d been doing just prior to the gut punch. The gut punch still needs to be dealt with - but now it’s just an event, not a thing that causes random spikes of rage and anger when I’m trying to drink my coffee.

And that’s how I learned a new way to deal with a gut punch.

-the Centaur

**Appendix.** The graphs above were generated via the following Mathematica code:

RandomGrowth[initial_, rate_, fuzz_] :=

initial (1 + rate) (1 + RandomReal[{-fuzz, fuzz}])

ProjectGrowth[initial_, rate_, fuzz_, years_] :=

NestList[RandomGrowth[#, rate, fuzz] &, initial, years]

InterpolateGrowth[initial_, rate_, fuzz_, years_] :=

Interpolation[ProjectGrowth[initial, rate, fuzz, years]]

FuzzyGrowth[initial_, rate_, fuzz_, years_] :=

Table[InterpolateGrowth[initial, rate, fuzz, years], {iterations, 10}]

fuzzyTwoPercent = FuzzyGrowth[1, 0.02, 0.05, 100]

Plot[{

Min[Map[#[x] &, fuzzyTwoPercent]], Max[Map[#[x] &, fuzzyTwoPercent]],

InterpolateGrowth[1.0, 0.02, 0.0, 100][x],

InterpolateGrowth[1.0, 0.01, 0.0, 100][x],

InterpolateGrowth[1.0, 0.03, 0.0, 100][x]},

{x, 1, 20},

Filling -> {1 -> {2}},

AxesOrigin -> {1, 1},

AxesLabel -> {"Years Downrange", "Growth Rate"},

PlotStyle -> {Thin, Thin, Thick,

Directive[Thick, Dashed],

Directive[Thick, Dashed]}]

and

Plot[{InterpolateGrowth[1.0, 0.02, 0.0, 100][x], Map[#[x] &, fuzzyTwoPercent]},

{x, 1, 20},

AxesOrigin -> {1, 1},

AxesLabel -> {"Years Downrange", "Growth Rate"},

PlotStyle ->

{Thick,

Thin, Thin, Thin, Thin, Thin,

Thin, Thin, Thin, Thin, Thin}]

I hope you enjoyed this exercise in computational therapy.