Monday, December 16, 2013

Cultural Engineering and Expression: Embassytown

A brief discussion of the fascinating implications of the linguistic architecture of China MiƩville's Ariekei of Embassytown. This largely focuses on the deliberate cultural engineering of linguistic forms and expression. There are spoilers in this discussion, but none related to the plot in any direct way.

I recently began reading (or listening to; I have a new found adoration for audio books) Embassytown by China MiƩville and, besides being absolutely fantastic conceptually, it has really captured my imagination of a possible future. In the story there is a species, the Ariekei, that can only understand communicatory acts if they are first instantiated in a signifying event. This means that, if I wanted to say "it hit my nerves like the grating wail of a thousand pounds of tinfoil in self-adjacent laceration," I would actually have to go get a thousand pounds of tinfoil and have it effect the collective perception as described. I would then refer back to that moment in order to make the expression intelligible.

What is interesting is that humans are actually like this. If the referent is lacking, the statement is lost; though, we can generalize to some degree. This is why my simile is probably comprehensible despite the fact that few people would ever have even seen a thousand pounds of tinfoil. However, in highly theoretical, hyper-contextual, or inordinately abstract domains, this problem resurfaces. People lack the eventful referent that
places the relevant topic in a space of intelligibility. As a consequence, when I am discussing these topics, I often take a shotgun approach with various metaphors, similes, and the like until one 'catches' in the listener. I then use that hook to build an architecture of comprehension around the topic in question.

The Ariekei do something similar but as a culture and species. Thus, in some way (as far as I am in the text, this is not yet clear) they sense that a certain form of expression is needed and they create the conditions for its manifestation. This then allows that expression to be made in future, applicable situations. I think this is a brilliant idea.

Imagine an international organization, something like NATO, whose sole function is to be sensitive to global fluctuations in cultural presence (local instantiations are equally viable and perhaps more desirable, depending on one's political proclivities). When the conditions suggest a need for a new form of expression, they collect all the elements (and, of course, it would be an honour to be so collected) and generate an event for global consumption. The entire world, as a whole, now can mutually recognize this experience and use it to communicate the underlying network of relations that were instantiated in that event. An easy (if not cutting edge) example that would be very relevant and useful today would be a global communicatory event for something like "unity" or "friend."

Religion, philosophy, and mysticism of various kinds has often operated as what I would call an unreflexive form of this organization. They manufacture clusters of these metaphoric referents that people use to grasp otherwise unintelligible experiences, but they do so in a way that is not aware of what it is doing. Usually this is because, in all but the most 'advanced' forms, the proponents of these views are entirely unaware that they are engineering as opposed to discovering (or that discovery is actually a creative act). Marketing and propaganda, on the other hand, self-consciously manufacture culture, but they do so as a byproduct. Science is somewhere in between.

As with many things I say, many might argue that this phenomenon already exists in a non-organizational form distributed within culture; thus, it is a given and mostly uninteresting. I completely agree, at least with the former. The issue is that this is equally unreflexive and, consequentially, it is driven almost entirely by chance and herd mentality. To build an international organization and navigate all the ethical, social, political, and legal shoals that entails would motivate an evolution in human thinking that is sorely needed. That itself would be an event worth communicating, an expression of yet unheard signification.

Images courtesy of:

Sunday, December 15, 2013

A New Project: Embodied the Book

I've recently begun working on a science fiction story, Embodied: A Search for Meaning, on a small portion of my spare time. So that others might enjoy this creation, I have placed it on my website, here. A description of the project is listed there as well.

This blogspace will also be a forum for comments on the first chapter (Chapter 0) of the first book, should people be so inclined. Future forums for future chapters will link back to here and vice versa (providing yet another hub in the network of digital relations). This means that you can check back here or on my website for future chapters and works.

Thank you all, in advance, for taking the time to read and comment on my work (especially if you enjoy it!).

A quick note:
When commenting, after you write your comment and click publish, it will look like your comment is up. However, in actual fact, there will still be a CAPTCHA for you to fill out before the content is really posted. Please be sure to fill that out that I might read your (hopefully inspired) mental meanderings!

Friday, September 13, 2013

A formula and proof for the reals

What follows is a proof illustrating my attempt to better understand this notation. I chose the letter f for "floor" and m for "mantissa."

I then wanted to better understand this m.

UPDATE: I have found that this might better be expressed using an integral rather than a sum. Unfortunately, I do not currently have time to explore this in any more depth. A future post will hopefully outline many of the other details.

Thursday, July 18, 2013

An Irrational Sum

I've been spending some time working on various forms of mathematics. I decided it might be interesting to post any insights I gather while working on this project. The first of those insights follows. It relates to how we conceive of the Reals.

First, I will introduce the new notation (I say "new" since a cursory search did not reveal anyone else using anything like it):

Immediately, however, I realized that this notation, despite being intuitively obvious, was a tad strange. It summed a series of the roots and then summed a fragment. 

I will eventually post a more thorough analysis that I have been pursuing, but I'm currently checking whether it is worth examining academically.

Sunday, March 24, 2013

Setting up matplotlib Python Package on a Mac

Thanks to this post, I've managed to get python and a few packages working on a Hackintosh running Snow Leopard. However, I found matplotlib to be particularly challenging, even with the instructions. Hence, for myself and others, I have decided to record my insights.

Once you have homebrew, python, and numpy installed as indicated in the post, above, do as follows in a terminal:

brew install freetype
brew install libpng

chmod +w /usr/local/lib
brew link freetype --force --overwrite

The last line should fail, but list a couple of files. Find the files (it tells you where they are) and delete them (or move them into a new folder for safe keeping). Retype the command and the link should occur. Then:

chmod +w /usr/local/include
brew link libpng --force --overwrite

As in the previous case, this will fail and list a few files. Proceed as in the previous case. Retype the command.

Finally type:

pip install matplotlib
pip install git+git://

You'll have to use the latter if you're using the Mountain Lion OS. It was the latter that I concluded with, personally.

Monday, March 18, 2013

Kruskal's MST Algorithm in Python

I needed this to create an algorithm that calculates base cycles in a graph. The code requires the disjoint set class from a previous post.

def kruskal_mst(vertices, edges):
  """Kruskal's algorithm that returns edge list of minimum spanning tree.

  For details see:'s_algorithm

  vertices - a list of the vertex names
  edges - a list of paired tuples representing edges e.g., ('v1', 'v2')

  span = []
  spanAdd = span.append
  data = DisjointDataStruct(vertices)
  for v1, v2 in edges:
    if data.find(v1) != data.find(v2):
      spanAdd((v1, v2))
      data.union(v1, v2)
  return span

Note: This is not a weighted graph implementation. To make it such, have the edges come in with weights as the first value in a tuple triplet. Call edges.sort() after data assignment and make the for statement read:

for w, v1, v2 in edges:

Disjoint-set Data Structure in Python

I needed this code to write Kruskal's minimum spanning tree algorithm.

class DisjointDataStruct(object): 
  """Disjoint-set data structure. 

  For details see:

  Public functions:
  union(x, y)

  def __init__(self, vertices):
    """My personal representation of the spaghetti stack.

    vertices - a list of vertex names from a graph
    self.struct = {v: [v, 0] for v in vertices}

  def union(self, x, y):
    """Joins subsets x and y into a single subset.

    Uses union by rank optimization.

    x, y - vertex names corresponding to keys in self.struct
    xRoot = self.find(x)
    yRoot = self.find(y)
    if xRoot == yRoot:

    xV = self.struct[xRoot]
    yV = self.struct[yRoot]
    if xV[1] < yV[1]:
      xV[0] = yRoot
    elif xV[1] > yV[1]:
      yV[0] = xRoot
      yV[0] = xRoot
      xV[1] += 1

  def find(self, x):
    """Determines which subset a particular element x is in.

    Uses path compression optimization.

    x - vertex name corresponding to key in self.struct
    if self.struct[x][0] != x:
      self.struct[x][0] = self.find(self.struct[x][0])
    return self.struct[x][0]

The timings are as follows:
__init__ is 17.5ms per loop in 100 loops with 100000 vertices (using timeit)
union has a mean of 1.0ms, standard deviation of 1.10e-7, min of ~0.9ms, and max of 1.0ms.
The union data was computed over the 224 union time values that did not equal 0 over a total of 100000 random unions of 100000 vertices (using time.time end - start).

On a single run of cProfile with a vertex set of 100000, and 100000 random unions where the two elements are not equal (I increment one of them if they are), I get the following values:
0.042s for __init__
0.197s for union in total (100000 calls) so per call is ~1.97e-06s
0.130s for find in total (299990 total / 200000 primitive) so per call is ~4.33e-07s

All of this was clocked running an i5-2500K @ 3.3GHz

Sunday, March 10, 2013

2D Wraparound World

I figured I would share a finding I had while working on a project. For those of you who have attempted to code a representation of a wraparound map (2D torus) using a 1 or 2D array, you may have found the experience quite challenging to get operating smoothly. I was trying to find a more elegant solution when I stumbled upon the following formula:

sqrt(min(|x1 - x2|, w - |x1 - x2|)^2 + min(|y1 - y2|, h - |y1-y2|)^2)

Where the two points are (x1, y1) and (x2, y2);
w and h are the width and height;
min and sqrt are minimization and square root functions, respectively.

With that the process is absurdly easy.

Note: If you just need relative distance for a comparison, don't bother using the square root.

Function courtesy of:

Saturday, March 9, 2013

Python Nested List

In a previous post, I outlined a python function for creating nested lists. In retrospect, it was a naive, if functional, first attempt. As the size of the various dimensions increases, the function would become quite slow largely as a result of the deepcopy calls and recursion. A more efficient method would use the following syntax:

nestedList = [[[baseValue for x in range(axisLength)] 
                for y in range(axisLength)] for z in ...]

Now, a naive attempt to turn this into a function might do something like the following:

def nestedList(axisLength, degree, base):
  for x in range(degree):
    base = [base for y in range(axisLength)]
  return base

But this will actually just create shallow copies. The problem is that base is not recreated at each iteration. However, this is fixable with generators. For example:

def baseGen(base, axisLength):   
  while True:
      yield [ for x in range(axisLength)]
    except AttributeError:
      yield [base for x in range(axisLength)]

def nestedList(base, axisLength, degree):
  for d in range(degree):
    base = baseGen(base, axisLength)
  return base

Then, you would just call nList = nestedList(None, 5, 3) and then ls = for a 5x5x5 cube with None as the base value. An added advantage of using generators is that you can just keep calling every time you want a new cube.