$disanpoter

a tyranny of lines

we have been duped by time. it has asserted in our minds the dominance of the sequential, the consequential, the linear. We write in lines, our speech doesn't double back on itself and our thoughts too, hamstrung by the means we have at our disposal to express them, we experience as linear. But our world is not linear. It is not cartesian; it is fully multi-dimensional, and it is frustrating to me that is a source of frustration for me that it requires such a steely grasp on our minds simply to begin to perceive it in the way it really is and to be able to contemplate that our own experiences of it are beyond our comprehension.

Perhaps all that is a load of crap I can't hope to substantiate. it seems to me that we already know that we do not think linearly, yet, we so often perceive our thought processes as such. We may perceive branches in the the thought process that takes us to a given conclusion but we don't see them occurring sequentially – or at least, if one begins with the observation that languages develop words of distinction for variations that are immediately relevant to the speakers of the language, then we certainly failed to develop sounder methods for expressing correspondence and synchronicity among events.

What's my point. I don't know what my point is. My point is linearity of expression is limiting us. My point is we would not be alive if our brains processed things linearly and we should try to tap that ability for our conscious minds as well as our autonomic systems. My point is if we try can we develop non-linear forms of communication. Can we have computers that are not strings of 0s and 1s or are we imprisoned not only in time but its aftereffect, that no matter how fast a neuron travels, it still is traveling in time across space, that no matter how sophisticated our object oriented programming languages and visual programming languages grow, they still must descend into a realm of tyrannical linearity before fulfilling their tasks.

I want to know. 

modrageous

mathmachinations is hereby declared its own category in acknowledgement of my blatant misuse of mathematical notions towards such perverse ends as interior wall painting, M&M consumption, and most recently linearization of object attributes. yup.

little did I know with I wrote that post this morning, that today would be a day of minor epiphanies. I was working on my schema structures and then my brain went like this:

• gee, there are alot of attributes for this schema system i've worked out
• this attribute really warrants an on,off, and null state; it's too bad chmod only accomodates 2 states per value
• oh...chmod is really just a series of binary characteristic represented with a series of values
• (and I already know that the mechanics of chmod is merely the geometric sequence 2^n)
• i wonder if any integer base could be used for the modularization then.
• i wonder if you could have modularized designations where each attribute had, say, 3 options.
• let's try.

2.5 hours later I concluded that the following system would allow for any depth of attribute options and number of attributes.

~Given a two-dimensional array $attributes with N rows and a maximum of X columns per row, such that for any $attribute[n] with X or fewer value options, an object may have at most one $attribute[n][x] . In other words, attribute values are mutually exclusive.

~Given exclusivity of attribute value, a sequence of numeric assignments can be established such that the summation of the attribute values of all rows is absolutely unique from the summation of any other combination of attribute values.

~Furthermoreusing X,N defined above:, this numeric sequence can be described in two parts as follows:
   1. each sequential value of x^n demarcates a distinct attribute
   2. each incremental value of x^n+ix < x^(n+1) demarcates an attribute value option
These 2 rules permit the entire array of attribute values to be weighted without the added burden of calculating the combinations or determining intermediary weightings. Conversely, despite the exponential increase in numeric values, the most iterations required to 'unpack' any combination into component parts will be N iterations. The unpacking process, based on sequential true false evaluations, requires no arbitrary or exhaustive value testing.