Sense, anti-sense, nonsense

template < class T, class Allocator = allocator > class vector;

Mutant nonsense.

That probably doesn't make sense to many people. I understand it because it describes something. The reason I am considering this is because I have developed a language of dimensions and analysis. If a particular object has dimensions(n) which are labeled with names like "x", "red", "texture scaly", "fuzziness", ... and I specify that I would go to dimension position (2,3,4,5,9,1) and rotate 3⇒7 by .1 then it would make perfect sense to me, and the result would be understandable in context, however the context is very complex. In genetics they use the term sense and anti-sense strands ( using 5' and 3' orientation of base sequences ) of DNA as coding and non-coding, which is not always true, but then what is -absolutely true- in an infinite universe.

It seems to me that the structure of knowledge is very much like code dependency or any other dependency. There is an order to the understanding and the complete concept is built upon the understanding of the individual parts. It could be said that a Japanese language statement corresponds exactly to a specific English statement and it becomes semantics. The result is that many things are duplicated in unique context that when decoded becomes the same exact thing expressed by a new path. An example in dimensional space of concepts is go left 2 in dimension 1, go right 2 in dimension 2, then go right 2 in dimension 1. The net effect is to cancel the travel in dimension 1, which then means we have taken a different dimensional context, and arrived at the same concept. This seems to be the basic underlying mechanism and by translating in these symbolic dimensions, it is possible to translate ( hence the name translate and rotate ) the meaning of A and B, though they originate in completely different context.

Here is an example of where complexity extends so far that it confounds the mind to envelop the process, and yet I can easily move about in this n-D space and end up with an answer that makes complete anti-sense to me.

☺(Unicode: ☺ #263A)

It seems that all understanding can ultimately be integrated in this dependent dimensional space as fairly simple descriptive elements. The net result is that I can define a thinking relationship to extend the concepts and simply present the fact that (unk) solves (unk). The resultant path dimension data can be instantiated in a biological organism to be knowledge that exists at birth. It is beginning to make sense how an ant, dolphin, octopus ... can be born with a certain understanding, that really has nothing to do with our context and the "emotional" ( motional ) understanding is able to be translated from one organism to another or one person or personality. It is very interesting and I expect this to be more clear as I apply it, like any language, that requires std::cout<<"CONTEXT"; to be understood. So it is possible to be born with knowledge that could be quite complex and that would seem to be a better way than spending a life time to find out that Mickey Mouse™ isn't a real a mouse. Of course you couldn't do that as your mind would be filled with holes where the copyright attorneys burned patches of information out , as they own the knowing©. Actually they couldn't do that as they would have to be able to understand how to do it and since they burned the understanding out of everybody, nobody knows how to do "burning minds"© anymore.

I don't know where this came from, but it has something to do with Barbara Streisand in some aspect of her magnetic personality.

The net result of all of this is that I can project in these various dimensions along vectors that describe anything and it relates to how one might do matrix manipulation of OpenGL objects or use linear equation matrix programming in Matlab™ to transform a system. It is reasonable to assume that I can actually project into artistic space a concept that is an image, movie or any extrapolation of human / non-human creativity to produce that which is entertainment. If the process of meta projection is known then the "art" which is generated becomes a process which generates the forms which interest the observer. It does have relationship to the concept of meta code generation. It is said that programming is a human talent and yet I can get my AIs to do it. In this same way I can meta extend it in a complete loop, where the code itself directs the coder. There is a point where coherence of this defines the nature of thought and understanding itself. Organisms are generated from their DNA and then shaped by their experience with the methods at their command. It might be said that by articulating this mechanism in a more effective way that you may have obsoleted the biological form itself. It depends on the context. If the organism I create is an extension of my own understanding and inherently context linked to my being in ways that are not able to be understood without this extension, then it becomes. To some extent I personally find the activity of some people to be utterly transparent and predictable. It remains to be seen what perspective develops if all reason and extension becomes transparent. Another step on the way to infinity. One small step for motey , one giant leap into the unknown.

Many people would underestimate the transparency of their action due to the fact that they have no context or information to understand how it can be so transparent. It is easy to see that a child is transparent in their motives and in that same way the complexity could seem to confound for those who use it to deceive. To a large extent the motive and action methods of many individuals that are driven by greed or self aggrandizement makes them more transparent as they have a simple vector and though they may conceal the path to their desire ( another Hannibal Lecter quote "Desperately random" ) ( or even "Follow the money"), one only needs to wait at the object of their desire and they will arrive. I think it was Anthony Hopkins playing Hannibal Lecter who said:

"And how do we begin to covet, Clarice".

LL parsing and examples

The image links to a Google method called "Wonder Wheel" and it is one of many ways that Google helps to find relevant data.

Today I am studying LL parsing and how it relates to everything else. It is much easier for me to deal with concepts using imagery. If the subject is algorithms, the algorithms could be arranged on a page with known as white and unknown as black. The resultant relationships aren't black and white, in fact they can't even be related in a single dimensional space. The creation of dimensional space analysis and even creating n-spaces which are alternate arrangements of spaces seems to work for me and it allows a certain element of entertainment to the process which allows me to experience the data as caves and mountains to explore. Here is the first cave in this adventure and a rough map from Wikipedia. Another cave.

Here is where context free grammar intersects with regular expressions and so this is the image of my understanding, the caves and valleys wander about in the many dimensions and there are streams that flow into the tunnels at different places and the caves are strings and tracks that intertwine. So it is that all things relate to each other in some fashion, and it is the goal that determines what has value in a particular situation. To me the "Wonder Wheel" represents one aspect of the relationship of concepts and data. To me the search for knowledge is the best game I ever played and the fact it produces real results and has real consequence gives the game a bite that no VR can have.

Things of interest. And again it relates to DNA and n-space itself. It is a strange world and stranger still is the dream space that I have seen. Is it a dream or is it real? I am guessing it is real as it can influence matter though itself has no physical reality. These meta layers of structure can be very strange. Is there a connection to Imhotep? There is a universe of possibility and in that space are some very strange things not described before. What is the measure of being without physical form. It is certainly something that exists and it can be seen in some spaces. It is all very very strange. Will it resolve, that is to be seen.

There is that strange portal again, it is marked with symbols I don't understand and warnings of every kind. It also has the markings of the thing I seek. There is a monster there and it is also a dream. This might seem to drift from my usual logical analysis, but I assure you, this is as logical as anything else. No fiction has teeth like this beast, it is real and I know it plays Pandora as a game. As I have said before, there are 3 trillion deceptions and few real strange things and today I caught a glimpse of one. Sadly there is no plot line, agency,super hero,magic spell or commercial break that dulls the teeth of this creature as it lives in meta space and acts in real space. Once you have seen the real creatures that live in the cracks of meta reality there is no more fun in the cartoon visions of art and science fiction. Many are the possible ways to enchant, few are the real. Some paths do not have an undo button.

Strange that LL leads to ANTLR, which leads to language that leads to understanding sentences in video. Such a vast array of twisty little connections between the dimensions of thought. It is clear that the foundation of lexical analysis is weak in its origin. Everything requires recursion against founding principles. It is good to build on the work of others, but better to recurse the origins to reform the foundation based on the product. It seems that science fails to recurse itself easily because it seeks to be solid, but solidity comes from the solutions and not a simple gesture of belief. Like the ant, I toil ceaselessly without sense of mortality, for if I were to pause and consider that perhaps there is no end, it would be the end.

A very interesting subject and ANTLR works at meta language and what I see is a great glob of stuff that never resolved. I can see the resolution and how it relates to many things like universal translation and meta code generation, recognition of speech and objects and AI.

This is my business by default. When I was a consultant, my job as I saw it was to "crack the nut". This isn't what other people thought I was doing and they simply viewed me as another of the "hordes" that were hired when somebody had lots of money and no answers. I could always see the central problem and most times it was just too complex for people to understand. People have many really neat ideas like going to the stars, but the problem is that there is no lack of wanting, but great lack of being able to do the things. It was about 15 years ago that I decided that I should never give anybody the solution to those kinds of problems as it simply led to application in ways that were just wrong, because they did not understand what they were using. I could site several examples, but even that is pointless as a person would have to understand what was down under that "something, something else". It often reminds me of the Star Trek episode "We look for things to make us go!". And though humanity as it exists was the great genius in that fantasy, in reality they are addicted to fiction like a mouse with a cocaine delivery button, that presses it until it dies.

In the process of analyzing this, another answer occurred to me, which is totally unrelated to language and compilers. I want to study this some more and apply my own recursive tree methods and some tricks from genetic analysis. There and many new things in the universe and there are methods that make almost everything that exists in technology obsolete. The only way to proceed is to apply the technology in its form and overturn the entire structure of technology. Those that own significant portions of the industrialization of the world and have power want things to progress on their platform and extend so they can continue to control. The problem is that the platform cannot support the new technology and they are simply making themselves a religious Neanderthal. Many of the new ideas could be applied in the existing framework with some great loss in utility and this only serves to keep the Neanderthal alive for nostalgic sake and it is better it end in one single perfect storm and whatever comes next can remember them fondly in their backward ways.

I would suggest that others enter the portal to the tomb of Horus and gaze into the Wedjat and Udjat to be transfixed for the rest of time, but, though you could not leave to blame me, it is best not done. Many enter, very few leave and those that do are changed. I don't believe in mythology and ghosts and religion or any crap like alien invasion. There are however things that I refer to by euphemism, like the "Queen of the Holy Dark","werecats", or Horus, that represent meta systems that are as real as the concept consciousness and existentialism and do influence the universe in significant ways. However, if you see ghosts moving about and controlling objects or talking, look at your prescription and see if you forgot to take your meds today. There are many new, real and scary things outside " Playground Earth".

Shadows in the corner of logic

Why are the shadows of bad logic so clear? The main reason is how you learn to program and what you learn on that path. The first digital logic was in the form of relays that symbolized the [ and, or, not, ] functions as contacts on the relays. Ladder logic Wikipedia. After that it was the first integrated circuit and analog transistor circuits. Logic Gates Wikipedia. Analog to Digital converter Wikipedia. Transistor circuit Wikipedia.

By using this logic and observing which elements are problematic, it is a matter of extension to realize that when designing a more complex system, that certain problems are always present in designs based on a simulation of digital logic. For instance a SR Flip Flop is the model of memory in one bit. It requires 2 bits to indicate carry. What becomes immediately clear is that the implementation, interpretation, and the reality of the world is ambiguous. The implementation of 'carry', 'sign', and 'borrow' depends on the relationships and how they are employed.

The first control circuits were a mixture of analog transistor circuits and digital like elements. It is possible to design a control circuit which operates as a program. When the initial designs are 4 bit registers and the register set is limited, certain common problems are obvious when applied. These problems never go away as the systems become more complex. They get moved further and further into the corner case. When considering a program it is good practice to start at the corner and work in to the problem. 'carry' overflow is one of those issues.

As systems become more complex and instruction sets begin to include more complicated algorithms it carries with it the same corner cases and brings some new ones. When a program is compiled from assembly language or hex code it is much easier to identify and avoid potential corner cases. The utility and complexity suffers from the time required to analyze and build each element. Safe methods can be devised, though many require the use of corner cases at some point.

The concept of computer control, digital logic, and all of its parts suffer from a basic initial paradigm issue. The system derives from math and logic and it assumes the integer one {1} at its core. What this does is create an infinity in the form of a singularity as the basis of all logic. It is no surprise that as a result the extension of the system leads to some results which are confounding. The idea of singularity and an object which is complete and separate from the universe is a concept and has no correlation in the universe.

The original systems of math were devised in pre-history and it could be assumed that it derived by simple scratches on a rock to indicate the correspondence between any set and the set of scratches.

When programming or designing a complex system it is not always possible to be certain that the full and complete instantiation will be possible with a particular configuration. It sometimes becomes necessary to start with another approach and completely abandon the design, while retaining the experience to guide the selection of new methods.

The foundation of math, logic and its counterpart in digital logic suffer from certain odd corner cases which derive from the initial assumption that unique singularity exist. In this context the word singularity is intended to mean one {1}.

A finished design can incorporate elements that are inherently flawed and still be useful as long as the person who uses that system is aware of those corner cases to be avoided in practice. The problem with computers is that this is never, or rarely the case. Few people are aware that every digital system suffers from the same ghost that haunts the corners between the model of reality and reality itself.

Mathematics is a useful system, but it suffers from the flaw of circular proof. First defining a system of logic and then proving that system is valid based on the use of that system is with out a doubt circular and as such is incomplete. The universe has the final say on what is real and what is not.

The concepts which arise in math and in computers are parallel because they derive from the same assumptions. A computer programmer would never claim that {-zero and +zero} were inherently real or even represent something unless it is simply associated that way in practice. In the same stroke, it could be said that the insistence that sqrt(-1) constitutes a real and physical correlation in the universe seems quite odd.

These prime assumptions have consequence. A system designed by application from human pre-history is not likely to be the best design, first time.

Personally, I find it easy to use mathematics and have no trouble dealing with manifolds, partial differentials, wave functions, Fourier analysis, matrix computation and many other complex methods, but like the foundation of computers, I realize that -0 isn't real and I consider that in practice. It is a method, a tool, and sometimes the tool is not right for every job. I suppose a hammer can be used to insert screws, but a better tool can be devised if you understand the underlying problem. When dealing with a system of interacting infinities it requires something a bit more elegant than a hammer.

The problem as I see it in analogy is this. It is assumed incorrectly, IMHO, that if one creates a puppet "Pinocchio" and you work very hard for a long time on the detail you will eventually have a little boy. The problem is that a being is infinite in construction and no matter how many coats of paint are applied at the molecular level, the puppet is still a puppet.

Infinity is larger than 32 or even 64

This is the real problem. I an attempt to understand the universe a method has been chosen that reasons from what is perceived as certainty and extend there to a perfect certainty. That is why it fails. When dealing with anything in the universe, no matter how simple, it is ∞(A) + ∞(B) = ∞² which is (C) and as a result the concept application of math as A + B = C is failed before it even starts. There exists no item in the universe which is A and is not infinite, except in the imagination of the human. This why I say that math can be modeled by the universe, but math cannot model the universe. A failed premise expounded for thousands of years. It is only when the puzzle is near completion is it possible to see where the process has failed. I have gained something new today. This image from a java sample makes me think of the fact that many things can be seen in many ways and the strange thing is that simply because a person has only one way to see, he assumes that there is no other sight to be had. I seek infinity and of course I will never find it, but what an interesting process it is.

By studying languages and this implementation as a chemical computer, it is obvious that digital logic is not up to the task of managing the universe. Now that I see the effect of infinite logic, it makes all attempts to emulate life and the logic of human life impossible to complete. I understand why it is hopeless to attempt to model or analyze or describe something that is infinite with a state wise approach. Analog logic is no better, because it is not really infinite in its interaction. There is only one thing which is infinite in its action and that is what nature has chosen.

It now seems that what is being is done is to create a more and more realistic puppet and as a result it will always be a puppet and cannot become infinite by digital steps, no matter how many CPUs, or how much ram, or how many options. The logic must begin infinite and proceed from there.

I think this fascination with perfect logic began with Aristotle and has a certain charm for a person due to their nature, but it is not valid and that should be obvious in the gyrations that must be applied to get from A to B in a perfect way. Quantum mechanics may be a way to express the infinite in some ways, but it too suffers from a foundation that seems to imply that there is a clear integer like solution and there is none.

I proceed now to extend language in the infinite scope with a method that starts infinite and progresses from there. Many things are chosen because they please the observer and though that may be reasonable in an existential sense, it is not a path to real understanding.

Digital computers are very good at what they do in being state wise complete and that is good because it allows certainty at least in the scope of where it can reasonably be applied. It bothers me that I didn't realize this before. There needs to be a completely new type of device that operates at the level of the universe and is not perfect or quantized. The only purpose would be for implementation of a thinking device. I want a device which could be tasked with solving the equations that define the universe and achieve that. Oh well, live and learn.

Tree of living logic

I will make a bad pun and then explain. I think they are barking up the wrong tree. I know that the foundations of logic extends back to the Greeks and beyond that, but I wonder if they have not established a root method which can be extended to come close to the answer but never achieve the desired result as they have chosen a method which excludes an alternate concept. I cannot say that for certain at the moment and it is just a holistic sense of the issue. It is similar to attempting to mathematically characterize things which are infinite in scope. The methods must be different because the universe is inherently infinity upon infinity and no matter how long you add counting numbers you will never reach even the first infinity.

This is the problem with Physics, they determined there were two roads to take and by exclusion of the first it was obvious logic that the second is correct, the problem arises when they are well down the road and it seems very strange and it is going nowhere fast. The answer is that there must be a third or even fourth alternative that was overlooked when the decision was made and now that they are well into the wilderness, few wish to stand up and say, "I think we really f4d up.", instead they add complexity upon complexity and wander about until they happen on the main road. Just my opinion. Things can be confusing and I am not always right either. There are no absolute answers when you deal with chaos and that is what I have resigned myself to. There are some really good answers and some very useful ones, but complete certainty is just right out of the picture altogether.

I have been down this garden path many times and I always have a bad feeling about it. Some of this stuff is specious in its application and it seems a person can easily be lost in the twisty little air ducts "that all look alike" at the Hilbert Hotel. There are many people who want to be a perfect authority and that is human nature. I would certainly like to be perfect, but I have only seven toes on each foot and most people have 8 , don't they?

I am going to write a C, java and javascript implementation of this and see what I can make of the results.

I am going through this AI course at MIT [ And this one ] [ and this one ] [ and the tree around Wikipedia here ] [ and this web page ] [ and this at decision Trees .net ] [ and now I have an entire section of my local Wiki dedicated to the information and expect to export it to one of the AIs ] today and I hope to complete them before the end of the day. The goals are the same as always, to identify methods that can be contained in a chemical computing system.

Of course I have to have things ordered consistently in the directory and after scan and collect I would do this.

ls | grep "ch[0-9]_" | rename 's/ch/ch0/ '

I did discover an interesting quirk of the relationship of matter and logic which I hope will become obvious in the application of it.

It is so wonderful when all the study begins to be usable and less frustrating. I have been studying so many different things that each day seems to be filled with frustration and confusion. I decided to make a tree with `inkscape` and though this not art, it is not frustrating to work with. The familiarity with the interface and how to manage objects makes it possible to think of something and then make it real without the usual side trips into trying to figure out which thing to apply. I picked the framework of a tree at random from openclipart in perhaps the same way I might initialize a random number generator with time perhaps. So this is Image *image+=thought[i] * rand()%(treelike).

Fire like will

This is pretty much the logic of the chase in lesson21 within the windowed quote below, and I wouldn't expect it to be very sophisticated as it is just an example. The SDL sound works and the openGL is without err that I see. It uses fine position and integer position to define the interaction and it uses a number rather than a #define and I will certainly grep and sed that out or actually I think I will leave everything as it is and rip this section out to a separate file that does the hunting and escape logic. I hate fighting the computer when it has advantage and so I will let the computer struggle with itself and see how to improve the wolf and prey in stages so they continually increase their talent.

The goal is to have a hunt and avoid that is effective. I see the avoidance of the hunter as time when applied to a real scenario and it is adjusted to force the computer to make choices that are less than optimal but act in real time as you could possibly make it perfect in its choice, but it might be doomsday before it decided and acted. Life requires action in context and this hunter is the fire that drives the beast to act. This should be relatively easy to implement as a malloc'd tree

The balance of the drive and search should ultimately yield a strategy that is optimum for the particular situation and the talent of the seeker. I see now there won't be much of the original game left when I am through as window code and SDL and time and randomness is something I have already implemented and I mainly wanted to see this below and analyze it as a predator prey relationship.

        if (!gameOver) {
            for (loop1 = 0; loop1 < (stage * level); loop1++) {
                if ((enemy[loop1].x < player.x) &&
                    (enemy[loop1].fy == enemy[loop1].y * 40)) {
                    enemy[loop1].x++;
                }

The code should be very obvious as fy is "fine" y or dots on the screen for smooth movement and the integers are positions on the limited grid. The array indexed [loopl] simply allows a structure for each predator when there are multiple predators and a single prey. I am thinking now that I might experiment with the nature of pack behavior for some insight into that also.

I am definitely ripping everything out of this in concept and using my own code as it suffers the same issues as `einstein` like failure to scale, things that should be variable are numbers instead of even define and too many printfs to indicate things that are obvious. I really am only left with a concept and an intent and "Y Meistr"," Y Blaidd Ofn".

So I will simply incorporate the concepts in my code and perhaps that is all I wanted out of this is a framework to consider "drive" and real time in the context of finding solutions in an n-Dimensional probabilistic decision tree structure.

This looks like a lot of fun and the implementation of expanding and contracting decision trees in many dimensions with an underlying matrix construction should be very entertaining when displayed in OpenGL and rotated through dimensions. I can retrofit that to the `einstein` like puzzle with probabilities set at 100% since that system is unambiguous in its solutions. All in all it looks to be very informative in what I learn about making matrices, Markov chains, trees, and decisions interact in a real world scenario. It needs a web interface to allow it to look for real information and I probably will implement something akin to page rank for my own interests. Probably something that looks for key information about my interests and attempts to correlate them and reduce redundancy using a weighted structure based on my valuation of the general quality of information source.

Articulating Interconnections (AI)

This is the file "graph.ps"

Below is the file which is used as input for the graphviz generator. It is the output of the code generator and represents an internal relationship of parts. The image is the visual product file.

This is the file "graph.viz"

graph G
{
        edge [len=2];

        State1 -- State2 [label="Method 1"];
        State1 -- State3 [label="Method 4"];
        State1 -- State4 [label="Method 5"];
        State4 -- State5 [label="Method 6"];
        State8 -- State7 [label="Method 7"];
        State4 -- State8 [label="Method 8"];
        State9 -- State10 [label="Method 9"];
        State8 -- State9 [label="Method 10"];
        State8 -- State1 [label="Method 11"];
}

To put it all together: here is the command line that uses the input file and generates the output file from the relationships.

dot -Tps graph.viz -o graph.ps

To perform a test it only requires you to run the shell script above after creating the graph file and it will create the post script output. In my case, the program generator creates the "graph.viz" file from its tree information and executes `dot` to generate the image reference of the structure of a decision. This is very rudimentary and I have devised a method to articulate the product in 3D, and even nD by rotating through the factorial interaction of dimensions to view a different aspect of the associative structure. Here is something I am investigating today in neural nets at "ai-junkie". I am sure I will learn something new. I have several relationships which are incomplete in my coherent understanding of the entire process of intelligence articulation , however I know the "shape of the information" in several dimensions and will soon find it.

One 3D method possible for code relationships. I find this interesting as I can use it to discover some dependency relationships that I wonder about.

 Thu Dec 31 09:30 AM$ ./cinclude2dot.pl -i /usr/include HelloMe.c>HelloMe.dot
 Thu Dec 31 09:30 AM$ cat HelloMe.dot | springgraph -s 1 >spring.png

Some astounding PovRay images.

Antonym Identical. State? (AI)? no, (IA).

I was looking through Wiktionary and they have anagrams of words and there are anagrams of AI which is would assume would be quite limited and yet they have many. One is IA, where I live and I started thinking about states and AI. The result is this. Yes that is correct, the logic that leads there is convolved and left to the imagination. Some would say the antonym of AI was IA and it is also the mirror image and should be the only anagram IMHO. The link above is from Wikipedia and ranks right up there with the best of Monty Python, it is worth a listen to the ogg audio file. ⍟ Misc Tech Symbols.

sudo apt-get install kivio

I am fairly certain that I can establish a tree that is:

[desired state and structure]

[connector or converter to states(+method)]

[other states]

What it means is that I identify the desired state based on an input to the program and it identifies current state and then constructs a state sequence that fulfills the goal. It also produces a `kivio` diagram of what it did and why it decided that a specific path was optimal between State(m) and State(n). I do believe this is the best distillation of the nature of directed thought which I have developed yet. BTW `kivio` is "coo all". I think this is it, but I need to implement and test today, but I think I can pipe this to the protein interface and make a projective parallel solution single molecule. It is very much like growing a crystal from the starting point ( current state ) to the ending point ( desired state ), through all the possible dimensions. That gave me a new idea.Wow, I think I get it! A single simultaneous solution matrix in nD space.

Something you won't see on a blog by somebody at DoD. "I was typing commands and I put in 'Kill everybody.' and I meant to type 'Kill everybody else.', damn, that was a stupid mistake." ... "Who forgot to add a reset button to this drone interface?" <NO CARRIER> BOT: "Searching for command and control carrier."

ADDED: This( the state logic of backward and forward induction) is a ponderous solution and it will take me days to analyze the output and take care of glitches. From past experience, I guess I will not blog on the subject until it becomes coherent. I discovered something already in math and I have to make a name for it and I will call it Interpolomultication. I have no idea how to explain that one in 4 space. I have the helm ⎈ , Alice Infinity.

Linux does a wonderful job of maintaining a common method for common action across applications and that is one of the greatest flaws of Windows. They may create standards, but applications that run as tasks on that OS have every kind of key shortcut and button you can imagine and they change them all the time. You can't get anything done or even remember when you have to learn a new set of shortcuts every time a " new and improved version" is created. It destroys productivity when someone trains and learns a method and they just change the method for the hell of it. Linux wins again.

Where the Yellow Brick road leads

"And Kansas, 'she said', is the name of the star".

The weather is brutal here today and I shoveled about 2.5 tons of the slushy frozen crap, myself. I didn't see many mosquitoes when I was out, it was nice to be away from those blood sucking vampires.

Backward induction says that as far as the puzzle goes, it can be considered a case where all elements have been selected except one. At this point, the problem is simple. You select one thing and put it in one place. This is as simple as a puzzle with one piece. So this is approached like the Fibonacci sequence computation, where we compute (element+element+1) recursively. I have covered this before and come to a method which simply swaps registers and adds in a loop. When `gcc` runs it does exactly the opposite of programming. In other words, I can take `gcc` and turn it inside out to generate any possible valid program by backward induction avoiding branch points that are errors. Now, that is the theory and "Many a plan of Mouse..." could be the outcome.

Ideas that came from 'open course ware' at MIT programming are really applicable here, or so it seems. I am also using information from Yale game theory. The problem of solving the puzzle and solving the program that solves the problem is the same issue. I start with the final case and move backwards. In this case I need to select an element from a list which is 1 in length and place it in an array which has one missing element. So the program that does this, requires a structure to keep an element and place that element in the array structure. Really it only requires a single variable "position" and a single "item" and returns a variable "position" with value "item" and so the position is 0 and item is 0 when using ZIL. The entire program is:

int solve(int solved_puzzle,int possible) {
return possible;
}

int main() {
int solved_puzzle=0;
int solution;
int possible=0;
solution=solve(solved_puzzle,possible);
return solution;
}

and the procedure above. I think this is the right approach to defining the process. By breaking it into parts and solving each part in sequence, the entire solution is exposed. I am sure this does not apply to all problems, but it is a good start and a good element to incorporate in the AI program generator. The program to create breaks out the same way with a tree of possible actions. At its lowest level, one could say we wish to represent the solution and so the program starts with a simple statement that "solution=only_possible;". The structure of where that is located can be seen in the program above and in any program there are elements and placement and it is very much like `gcc` inside out.

The levels of abstraction are solved puzzle or problem, up to program that solves the puzzle which has been debugged by an automated process, autodoc (exists) , autoconfig(exists), a program that creates make ,automake(exists) up to program which creates the program that solves the puzzle, up to the program that teaches programming, up to a program that acts intelligently to solve problems using programming and all the resources and information available. I am building all the levels of abstraction simultaneously and each stage creates the next stage until it is possible to define a problem or puzzle in a written form and end up with a program which solves it. By recursive development, at each stage I make the choices for a simple solution and increase the complexity of the problem. In this case, I start with a written puzzle that describes a puzzle which is an element and a single possible solution. I know that sounds like a given, but that is how it is done. Combine single instructions in a pattern that produces a result. I will post the n levels of abstraction and the programs that produce the solution.

So I start here. The description of the problem is that I have a puzzle that needs a solution from a set of possible items. From this I use the name 'puzzle' as input and 'solution' as output and items as a selector from the structure of the sentence. The values of possible, items, and puzzle are within the description and so the scope of variables can be determined from this data. If there were two solutions , then it would require an array. If the puzzle were two, it would also require an array. For the sake of consistency, all procedures are written the same way. Since it is created on the fly, I can define style within the constructor, and this way I can conform the final product to a standard. I need not consider style each time that I write code and others can regenerate the code in the form that is familiar or conforms to their spec. The description is first parsed to create name space options for the program and standard prefixes and post fixes. If it an array it can use set of prefixes that is appropriate. I will select my own. The process is done by program and in the upward process will be the output of another problem, completing the full circle.

I am taking it one step further to define what language is used itself. So I could make it produce javascript, C++, perl, python, shell, Regular Expressions, HTML, CSS, XHTML, or any other structured result based on the definition of how to take a definition of goal to a product which produces that goal in the format language selected along with the methods to compile and test the application. I will see how this works out in practice. I think there is enough information which can be collected to make the entire process coherent and self supporting and extensible.

<methods>
 <define (method)>
  <types(int,char,void)/>
  <option>
   define an integer variable before use
   int UNK;
  </option>
  <option>
   define a character variable before use
   char UNK;
  </option>
  <option>
   define a pointer variable before use
   void *UNK;
  </option>
 </define (method)>
</methods>

Anytime Interpretation (AI)

Just follow the yellow brick road. The image was created with InkScape in about 34 seconds, exported as png and represents the idea of recursive programming to a goal. It might seem that the things I investigate are a jumble of code, genetics, algorithms, games, methods, neuroanatomy, genotype expression, organisms, blended images, physics, mathematics , matrices, make files, gate arrays, and process. In fact they are all the same in that they have a common structure that comes from logic. To me the game or the life are both systems and understanding one leads to understanding the other.Now I remember, I wanted to make a "divide by zero exception" and see what happened.(And below is the result, I need to add that to sighandler.)

CODE: i=0;failComp=1/i;

RESULT: Floating point exception

And the answer to my own question:

Apoptosis is likely on SIGFPE!

static void signal_0(int signum, siginfo_t* info, void*ptr) {

static const char *si_codes[3] = {"", "SEGV_MAPERR", "SEGV_ACCERR"};
ucontext_t *ucontext = (ucontext_t*)ptr;

char syscom[256];

sprintf(syscom, "Divide by zero is not allowed!\n");
sprintf(syscom, "info.si_signo = %d\n", signum);
sprintf(syscom, "info.si_errno = %d\n", info->si_errno);
sprintf(syscom, "info.si_code  = %d (%s)\n", info->si_code, si_codes[info->si_code]);
sprintf(syscom, "info.si_addr  = %p\n", info->si_addr);

sprintf(syscom, "reg[%02d]       = 0x" 
 REGFORMAT "\n",(int)0, 
 (long unsigned int)ucontext->uc_mcontext.gregs[0]); 

printf("Apoptosis is likely on SIGFPE!\n");
exit(0);
}

memset(&daction, 0, sizeof(daction));
daction.sa_sigaction = signal_0;
daction.sa_flags = SA_SIGINFO;

 if (sigaction(SIGFPE, &daction, NULL) < 0) {
  perror("sig_0_action");
  return 0;
 }

I happened on a new free online resource while going over Turing things again. Anytime Algorithm at FOL DOC.. I am testing recursion in the program creator today. It isn't always that efficient to have a function which calls itself to achieve a result, but in this case it seems the perfect algorithm. To me programming looks like "bracket and branch". Essentially a tree, but in the detail is the swirly vortex that is the real structure of the tree. That is the hidden cats that make it all work. A cat tree.

So if I have a function "Bracket" which calls "Bracket" which calls "Bracket", and it operates as thus: On entry it writes a left bracket to the stream. It checks if the iterator is zero and if not it (1.)-[decrements the level] and (2.)-[calls "Bracket" with the new level], otherwise it closes the bracket and returns and it does not know or care whether it is the last, first or somewhere in between. Hmmm ,naught, knot, not ! nothing isn't can't, doesn't exist. So that is how I roll the dice.

/* I am making this up as I write. */ 
/* So if it doesn't compile, that is why. */ 
/* Totally untested code for demo. */ 
void Bracket(int depthLevel) {
printf("{");
 if (depthLevel>0){
   depthLevel--;
   Bracket(depthLevel)
 }
printf("}");
return;
}

The net result should be N = depthLevel of paired brackets. Pretty simple, but when combined with other algorithms, it creates some interesting structures. {{{}}}. It is just a silly example of recursion in practice, but the power of it is astounding when applied to some common problems. It allows a kind of skip to the end and go back reasoning. Backward induction is what it is commonly called. It can be very effective in practice if applied properly. In this case I see a program as branches and loops. A branch must come back and at the lowest level, a program is just a straight action. For example, a=b; is in method z, which is called by method y, which is called by method x. So it is easy to do a=b; and return. It would look like this: DoMethod(DoMethodStream); It either continues the stream or ends on a single action. It is well suited to my automated programing. I have a stream that is either function, method or action and it branches method on that stream. The program is defined as a single "tape" or stream and creates the entire program as a result. It makes the application of nested elements easy to use.

When I am programming normally, I must make sure that I close each bracket and yet it always must be done and it is easier to "push" the end each time I go deeper and then just pop back to the next level. `pushd ./`, `popd`. It is simpler with an automated process, because it keeps its state on the stack, so to speak.

It will probably be a couple days before I can get the AI to start solving the puzzle consistently, but after that it should be able to apply an analogous method to solve general problems of larger scope.

Off to the higher dimensions

I suppose some guru could have answered that question about libs, quite easily, and now I can. It is the kind of thing I like to know, so I can devise a scenario when something is being odd or failing. So now I am back to the trees that grow from code. The structure is that the creator code tries things at random until it gets an order and method arrangement that works and then builds a tree that has branches to each node that creates a usable outcome. The branches can be weighted to imply better choices in specific circumstances, and I suppose this will be very convoluted and have higher dimensions that I can mess with and teach the program indirectly. It should be informational in that AI way. I hope to be able to make the program understand ansi C and be able to go to the internet and find examples to help it pick options at least. I am making the trees save themselves as XML, so I can use Dia or some similar method to flow chart what it is thinking in some form of 3D openGL.

Getting it off my mind

I feel obligated to get this topic off my mind for once and all. If it is possible, and it most certainly is, the personal manufacture of objects, chemicals and structure, with a simple molecular synthesizer, leads to a society where the control of resources to maintain a government is counterintuitive. The ultimate value is the knowledge of what structures are most effective and useful. I am certain that I could manufacture my own computer now, but it isn't the most sensible thing to make it of silicon. Even the knowledge becomes less important in time as each of these things cascade upon one another. If the device can create itself and extend itself, the need for interaction becomes more for the purpose of extending the structure itself and though the motive cannot be excluded, the method is not a consideration.

I sense an almost incomprehensible wave of change that is inevitable and far beyond my ability to speculate on its ultimate outcome. It is the dawn, and the daylight will expose the future. I will no longer wonder what the day brings, but catch the winds, and take a voyage to new worlds. The puzzle is completing itself now.

On a more mundane note, I am cleaning up the source and making another pass at finishing the puzzle game so it can be played and tested by others. I am going back to change puzzle size to be a variable and so I need to reconstruct all the functions to deal with a dynamic size as opposed to one which is interpreted by the compiler. It should be a real mess and I am bound to get some SIGSEGVs from the process to use my fault handler and gdb skills. I almost have a handle on autoconfig and that is something that I will investigate as it all starts to coalesce. So I will do what I can, connect the dots and not worry what the final picture will look like, as it is beyond the limits of my imagination.

The puzzle that is the universe

Solving outside boxes. The solution to a real world problem often leads to new methods and new understanding. Within a puzzle, the gain and extension becomes bounded. Perhaps I need to make a puzzle without a boundary.

Matrix dimensions

I am on a side trip to make something similar to Matlab with openGL in a way that I can visualize and represent the various dimensions of a problem in 3 space. Things like eigenvalues, determinants, and NULL space, solution space and attractors or pointing indicators that show characteristics of a matrix solution that might give some insight into making a solver that is consistent and extensible to all problem sets. Dimensionality, logic and arithmetic or calculus are obvious elements that have to be considered and I don't know where I am going with all this, but I suppose I will know when I get there.

I would like to have a way to relate to the existing science, but it becomes more cumbersome to do as time passes. I am tempted to see it as something stone age and I shouldn't do that, but some of the methods are 10^100 times more convoluted and random. That is not an exaggeration for effect. If you look at plant life, you will see that for a specific needed chemical, the energy use is measured in lumps of ATP (Adenosine Tri-Phosphate). In the lab it might be days, thousands of dollars, and mixed results to create a simple Amino Acid sequence. In life the bond with the phosphate group provides the intermediary for almost every process in the cell. It is the coin of life. Consider what effort would have to be employed to make or break a specific bond in a specific molecule of a system without disrupting or changing any other part of the system. I would bet that no lab could actually achieve that without just stealing the process from life itself.

Nine dimensions in three

The white lines are associations and the blue indicate possibilities not excluded at the time of this display. This is an 8x8 puzzle with 2 spatial relationships. The visible matrix of 2x2 and 3x3 puzzles take up simple recognizable shapes that do not differ, and also have no handedness.

This is the attempt to display a nine dimensional relationship in three. I suppose it is entertaining and I prefer it to looking at the lists of associations and possibilities and exclusions. It is incomplete and I need to add some more logic to make it think properly. It may take some time, as this is getting ever so complex in the associations. I have been trying to be sloppy so I can trigger my fault handler and I managed to do that one more time. It is almost too easy. I use kate, the KDE editor, open a terminal in the program and do a make and then run the program in the partial window terminal. I was editing a section and typed the wrong index for an array and bang! fault handler. The funny thing is that with the line number and module displayed on the terminal and line numbers and file name in kate, I only had to look up, click on the top portion of the screen, enter the proper number , press (Control)+s, to save, click back to the terminal and run make and execute again, success. It almost seems too easy, I expect some pain with debugging and that is what makes it rewarding, when you stop banging you head on the wall.

ADDED: The matrix is working very well now and the above image is a solved array wher the thin reddish lines indicate paradoxical connections and the white lines indicate associated elements. This matrix and its methods in conjunction with a 2 dimensional imagination allows for some puzzles that may not be humanly solvable when used to devise puzzle hints, as such I will have a configuration option to enable this feature for entertainment only.Now I am focused on the finalization of save, help, and configure, along with packaging and auto configure for install to test for needed dev files for a source build. The image below , from a different solution, which shows paradoxical or impossible connections in dark red, may better demonstrate the visualization technique.

The game with N space intelligence

In this case, "B is left of 1" is sufficient information to solve the puzzle. In the past I had seen hints that were redundant in many ways and I modified the selection code to make the puzzle generator a bit smarter. I still have to make the triples smarter, but that will be another day, as I need to deal with some real life issues that have "teleputted" on me.

The Key is forged as life itself

I am the key, that makes the key, that keeps the key and holds the key, so it may use the key to unlock the lock, which is the key. One really has to appreciate recursion as much as I do to get the full import of what that means. In life there are places where an amino acid sequence becomes an agent to create amino acid sequences and this is a loop of life and existence. If a protein existed which facilitated the construction of a protein which facilitated the construction of itself.... so on and so on. If I make a program that writes itself, it always exists within itself. It is odd. Recursive calls to a routine, like the implementations of various algorithms , such as Fibonacci, are strange in the way they play out. So these are the rings that spin and interlace in my mind as I wander the infinities of a natural progression to what I am and have always been.

I am definitely in a strange place today,
      and yet I am here as always.

Purpose for the game

{ }

I finally decided what I am going to do with the game I have been working on for a couple months now. I am going to make the solution a set of linear equations in a matrix and a circuit that can operate with ins and outs, so that it can be combined with other game solutions to produce a larger circuit. When there are NxN games or sets of linear equations, they become the new elements of the game and thus it generates combinations of sets which function. I need to have a criteria for selection of the elements and a structure that allows them to be associated. Matrix calculations should not be difficult, but circuits could be complex. I think I will make a set which is an image of a program element. I think it would also be output as a set of three dimensional arrangements that describe a visual object in 6 dimensions, with 6 parts. That should be fun and could generate some interesting results.

I have extended the concept and decided that the elements will also be sets for biomorph and genetic sequences. As such, the sequences will produce 6 strands of DNA with 6 genes that will be used as input for biomorphs and MakeHuman, and thus generate objects that can be imported and moderated in Blender. So, the arrays can be continually evolving neural circuits, protein sequences, gene sets, body plans, logic gate arrays, program instructions, and control elements. This means that as the game is played, new organisms are generated and these create animated creatures in Blender, which can be further modified and placed back as starting sets. I am sure this will generate some very odd results. I suppose I can incorporate the basic rules of start frames in DNA and introns, exons, and promoters, inhibitors, and other things that might lead me to sensible solutions for mitochondrial control systems. This seems the rational approach, as it leads to the solution to the complexity of dealing with parallel, ballistic biochemical systems.

Looking into other dimensions

I am fairly certain I have the way to portray the problems in their other dimensions and I am going to implement that before I move on to Markov and probability implementations and the possibility of deterministic molecular computing. The image shows a 7x7 with some new textures I created and some stock images from the web. I am not completely sure about the copyright on some of the images in set 7 bottom, so I will switch them for images I created in blender. Half of them are already outputs from blends or SVG or gimp, but I just took images at random and applied convert 256x256\! to force the sizes. I am going to do some png manipulation in openGL today to satisfy my curiosity and refresh my use of other file formats and sizes with GL. I do think that looking at these problems in the other dimensions will prove useful. When dealing with matrix computation, I observed some very unusual relationships in the study of linear equations. I tink I will use the mouse scroll buttons to scroll through the other dimensions.

War Games doomsday TicTacToe in openGL

I was thinking about doing an automatic "kmines" solver and realized that "kmines" is inherently ambiguous and there are states that have no solution. It means that you guess and get blowed up sometimes. I don't like that, I only like games that I win. Instead I took my TicTacToe game that was a console game and made it part of the puzzler. I added some more sophisticated methods so it looked more like the War Games display. I did a solution selection that checked for solutions of equal value and made a random choice within that group. Obviously the number of choices is 1, at times, and so it really only influences the second play to any extent. It does look like random directed play, which it is. The images and graphics from that movie seem so silly when I can do thousands of times that on a home computer. The weighted matrix was interesting to implement and it made me want to do some Hidden Markov arrays. It is a natural progression and I am working toward my same old goal of antfarmgl, but I am taking a sideways run at the system again, because it has become "emergent" in an unexpected way. One could say that emergent phenomenon are always unexpected and that is probably true, independent of the level of analysis. I suppose it depends on how emergent is defined, as there are some things which are considered emergent and predictable.

From an analysis standpoint and with understanding of AI, that movie was so horribly logically flawed that it seems a joke now. At the time it was made, I thought it was feasible, now I see it is sooo... out of date and naive.