eric the fruitbatBlog
Sounding out the Noosphere.

Posts from June, 2007

Universal Turing Machines, Part 7: Registration

Posted by Eric Hennigan
On June 27th, 2007 at 19:06

Permalink | Trackback | Links In |

Leave a Comment |
Posted in Comp*

Now it is time to determine the state that we will transition into. Because of the difficulty of matching a sequence of symbols (the little q) that is sitting in the middle of a list (the big Q’s) we will first copy this symbol to the register.

  1. Scanning left from the Tape marker, we can erase all the symbol markings, until we hit our current state
  2. Scan to the right until we hit the state that we transition into.
  3. Pick up the first uncopied bit (unless we see a Y or X in which case we can stop here and Accept or Reject.) Also, if we see a S, Q, or T then we’ve done all the copying we need to do, and can rewind the tape unmarking everything along the way. Otherwise, we start copying bits one-by-one in a loop.
    • Scan to the left until we hit the Blank Symbol marker.
    • Scan until we hit a bit that has already been copied (or the q at the tape’s beginning).
    • Place a marked version of the copied bit, and return to get the next bit.

\xymatrix @!=3pc { *++[][]{} \ar[d] & &*++[][F=:<5pt>]{Accept} && \\ *++[o][F-]{R_0} \ar@(ur,dr)^{{\scriptstyle \overline{0} \rightarrow 0,L} \atop {\scriptstyle \overline{1} \rightarrow 1,L}} \ar@(ul,dl)_{L} \ar[d]_{\overline{S} \rightarrow \overline{S},R} & &*++[][F=:<5pt>]{Reject} && \\ *++[o][F-]{R_1} \ar@(ul,dl)_{R} \ar[dr]_{q \rightarrow \overline{q},R} && \\ &*++[o][F-]{R_2} \ar[dl]_{0 \rightarrow \overline{0},L} \ar[dr]_{1 \rightarrow \overline{1},L} \ar[r]^{{{\scriptstyle S \rightarrow S,L} \atop {\scriptstyle Q \rightarrow Q,L}} \atop {\scriptstyle T \rightarrow T,L}} \ar `u[uu] `r^r^{} [uur]^(.25){ X \rightarrow X,R } \ar `u[uuu] `^r^{} [uuur]^(.25){Y \rightarrow Y,R} \ar@(ul,dl)_{R} &*++[o][F-]{R_{10}} \ar@(ul,ur)^{{{{\scriptstyle \overline{0} \rightarrow 0,L} \atop {\scriptstyle \overline{1} \rightarrow 1,L}} \atop {{\scriptstyle \overline{Q} \rightarrow Q,L} \atop {\scriptstyle \overline{S} \rightarrow S,L}}} \atop {\scriptstyle \overline{q} \rightarrow q,L}} \ar@(dl,dr)_{L} \ar[r]^{B \rightarrow B,L} & \\ *++[o][F-]{R_3} \ar@(ul,dl)_{L} \ar[d]_{B \rightarrow B,L} & &*++[o][F-]{R_4} \ar@(ur,dr)^{L} \ar[d]^{B \rightarrow B,L} \\ *++[o][F-]{R_5} \ar@(ul,dl)_{L} \ar[d]_{{{\scriptstyle \overline{1} \rightarrow \overline{1},R} \atop {\scriptstyle \overline{0} \rightarrow \overline{0},R}} \atop {\scriptstyle q \rightarrow q,R}} & &*++[o][F-]{R_6} \ar@(ur,dr)^{L} \ar[d]^{{{\scriptstyle \overline{1} \rightarrow \overline{1},R} \atop {\scriptstyle \overline{0} \rightarrow \overline{0},R}} \atop {\scriptstyle q \rightarrow q,R}} \\ *++[o][F-]{R_7} \ar[dr]_{{\scriptstyle 0 \rightarrow \overline{0},R} \atop {\scriptstyle 1 \rightarrow \overline{0},R}} & &*++[o][F-]{R_8} \ar[dl]^{{\scriptstyle 0 \rightarrow \overline{1},R} \atop {\scriptstyle 1 \rightarrow \overline{1},R}} \\ &*++[o][F-]{R_9} \ar@(dl,dr)_{R} \ar[uuuu]_{\overline{q} \rightarrow \overline{q},R} \\ }

The Microsoft Tax

Posted by Eric Hennigan
On June 26th, 2007 at 21:06

Permalink | Trackback | Links In |

Leave a Comment |
Posted in Comp*, Idiocracy, Self

I recently decide to purchase a Laptop. My concerns were: must be 64-bit, must be lightweight, should be tiny. Using the venerable pricegrabber, which lets you sort and filter by many aspects (and so beats froogle to a bloody pulp), I decided upon a factory refurbished AV4155-EH1 by Averatec.

The stats:
Amd Turion 64 Mobile-30 at 1.6GHz
13 inch, 1280×800 TFT screen
512MB DDR2
80GB HD
10/100 and 802.11b/g wireless ethernet
4.2 lbs

All for the rather reasonable price of $529. I plan on using it up at the local community college, because I don’t have an account on the machines in the library (I’m not a student, I just hang out.). Once I receive it Windows XP will be defenestrated in favor of Gentoo Linux.

After I purchased it, I called up the dealer and asked a sales rep if I could get it without Windows. He said “No, the factory pre-installs it.” And that’s how, even though I refuse to use Microsoft products they still steal money from me.

Universal Turing Machines, Part 6: Headbashing

Posted by Eric Hennigan
On June 26th, 2007 at 19:06

Permalink | Trackback | Links In |

Leave a Comment |
Posted in Comp*

Ok, so we just finished simulating a write, now it’s time to simulate movement of the head to the Left or Right one square.
This routine should be fairly straightforward.

  1. Scan back to the symbol in the transition table and read the L or R.
  2. Scan forward to the marked symbol on the tape.
    • If we are moving to the Right, then sail past and mark the next s, unless we hit a blank, in which case we’re done (because that will be picked up by the Copy Blank Subroutine the next time through the simulation).
    • If we are moving to the Left, then back up and mark the previous s, unless we run of the left end of the Tape, in which case the head is forced to stay on the leftmost square.

\xymatrix @!=3pc { &*++[][]{} \ar[d]^{} \\ &*++[o][F-]{M_0} \ar[d]^{\overline{s} \rightarrow s,L} \ar@(ul,dl)_{ {\scriptstyle\overline{0} \rightarrow 0,L} \atop {\scriptstyle\overline{1} \rightarrow 1,L} } \ar@(ur,dr)^{L} \\ &*++[o][F-]{M_1} \ar[dl]_{L \rightarrow L,R} \ar[dr]^{R \rightarrow R,R} \\ *++[o][F-]{M_2} \ar@(ul,dl)_{R} \ar[d]_{\overline{s} \rightarrow s,L} & &*++[o][F-]{M_3} \ar@(ur,dr)^{R} \ar[d]^{\overline{s} \rightarrow s,R} \\ *++[o][F-]{M_4} \ar@(ul,dl)_{L} \ar `dr^r[dr]^{s \rightarrow \overline{s},L} [drr] \ar[d]_{T \rightarrow T,R} & &*++[o][F-]{M_5} \ar@(ur,dr)^{R} \ar `dl^r[dl]^{ {\scriptstyle s \rightarrow \overline{s},L} \atop {\scriptstyle \Box \rightarrow \Box,L} } [d] &\\ *++[o][F-]{M_6} \ar `r^r[r]_{s \rightarrow \overline{s},L} [rr] &&\\ }

Universal Turing Machines, Part 5: She Puts the Symbol on the Tape

Posted by Eric Hennigan
On June 24th, 2007 at 17:06

Permalink | Trackback | Links In |

Comments (1) |
Posted in Comp*

The last routine left us conveniently positioned on the s character of the symbol which is to be copied to the marked position on the simulated tape. The marked tape symbol is also fully marked up, so as we copy we will be unmarking its bits, while the symbol in the transition function is not marked at all, but will become so during the copying process.

  1. Mark this symbol so we can come back to it later.
  2. Grab the most significant bit to be copied.
  3. Scan to the Right until we hit the marked symbol on the tape.
  4. Step over the bits already copied.
  5. Place the new bit into its position.
  6. Decide wether we are done or not.
    • If we are on a 0 or 1 then more bits need to be copied. Scan to the Left over the symbol on the tape and back to step 2.
    • If we are on an s or $\Box$ then we’ve copied all the bits and can scan to the Left restoring them to an unmarked state. Finally exiting with the machine head to the Left of the marked tape symbol.

\xymatrix @!=3pc { *++[][]{} \ar[r] &*++[o][F-]{C_0} \ar[d]^{s \rightarrow \overline{s},R} \\ &*++[o][F-]{C_1} \ar[dl]_{0 \rightarrow \overline{0},R} \ar[dr]^{1 \rightarrow \overline{1},R} \\ *++[o][F-]{C_2} \ar@(ul,dl)_{R} \ar[d]_{ \overline{s} \rightarrow \overline{s},R} &*++[o][F-]{C_7} \ar@(dr,ur)_{L} \ar[u]^(.3){{\scriptstyle\overline{0} \rightarrow \overline{0},R} \atop {\scriptstyle\overline{1} \rightarrow \overline{1},R}} &*++[o][F-]{C_3} \ar@(ur,dr)^{R} \ar[d]^{\overline{s} \rightarrow \overline{s},R} \\ *++[o][F-]{C_4} \ar@(ul,dl)_{{\scriptstyle 0 \rightarrow 0,R} \atop {\scriptstyle 1 \rightarrow 1,R}} \ar[r]^{{\scriptstyle \overline{0} \rightarrow 0,R} \atop {\scriptstyle \overline{1} \rightarrow 0,R}} &*++[o][F-]{C_6} \ar[d]_{{\scriptstyle s \rightarrow s,L} \atop {\scriptstyle \Box \rightarrow \Box,L}} \ar[u]^{\overline{s} \rightarrow \overline{s},L} \ar@(u,r)^{L} &*++[o][F]{C_5} \ar@(ur,dr)^{{\scriptstyle 0 \rightarrow 0,R} \atop {\scriptstyle 1 \rightarrow 1,R}} \ar[l]^{{\scriptstyle \overline{0} \rightarrow 1,R} \atop {\scriptstyle \overline{1} \rightarrow 1,R}} \\ &*++[o][F-]{C_8} \ar@(dl,dr)_{L} \ar[r]^{\overline{s} \rightarrow \overline{s},L} & \\ }
Thus our UTM so far looks like
\xymatrix { *++[][]{} \ar[r] &*++[F-]{Start} \ar[r]^{T \rightarrow T,R} \ar@(ur,ul)_{R} &*++[o][F-]{Hit \atop Tape} \ar[d]^{\Box \rightarrow \overline{s},L} \ar@(ur,ul)_{ {\scriptstyle s \rightarrow s,R} \atop {{\scriptstyle 0 \rightarrow 0,R} \atop {\scriptstyle 1 \rightarrow 1,R}} } \ar[r]^(.4){\overline{s} \rightarrow \overline{s},L} &*++[F-:<5pt>]{{Lookup\ New} \atop {Symbol}} \ar[r]{} &*++[F-:<5pt>]{{Write\ Symbol} \atop {on\ Tape}} \ar[r]{} &*++[F-:<5pt>]{{Move\ Tape} \atop {Subroutine}} \\ & &*++[F-:<5pt>]{{\scriptstyle Copy\ Blank} \atop {\scriptstyle Subroutine}} \ar `l[l] [ul]{}\\ }

Universal Turing Machines, Part 4: Symbol Lookup

Posted by Eric Hennigan
On June 24th, 2007 at 15:06

Permalink | Trackback | Links In |

Leave a Comment |
Posted in Comp*

All right, so far we are assured that a marked symbol is on the simulated tape, and the machine head somewhere nearby. We will now have to find the appropriate transition rule in the encoded machine. We will loop through the possible transition functions until we find one that matches with the symbol on the tape.

  1. Scan to the Left until we find the marked transition state, Q.
  2. Scan to the Right until we find a transition symbol S, and mark it with a S.
  3. Grab the most significant bit of this symbol’s number that hasn’t already undergone a comparison, or exit if the comparison has completely finished and no more bits are left.
  4. Scan to the Right until we find the marked symbol on the tape.
  5. Skip past the bits that have already been compared.
    • If we match, then go back to step 3 and pick up the next bit in the symbol.
    • If not, then go back, erasing all of our markings along the way, to step 2 and pick up the next candidate symbol in the transition table.

\xymatrix @!=3pc { &*++[][]{}\ar[r]{} &*++[o][F-]{S_0} \ar@(r,u)_{L} \ar[d]_{\overline{Q} \rightarrow \overline{Q},R} &\\ & &*++[o][F-]{S_1} \ar@(ur,dr)^{R} \ar[d]_{S \rightarrow \overline{S},R} &\\ & &*++[o][F-]{S_2} \ar[r]^{ {\scriptstyle L \rightarrow L,R} \atop {\scriptstyle R \rightarrow R,R} } \ar[dl]_{0 \rightarrow \overline{0},R} \ar[dr]^{1 \rightarrow \overline{1},R} &\\ &*++[o][F-]{S_3} \ar@(ul,dl)_{R} \ar[d]_{\overline{s} \rightarrow \overline{s},R} &*++[o][F-]{S_8} \ar@(ur,dr)^{L} \ar[u]^(.3){ {\scriptstyle \overline{0} \rightarrow \overline{0},R} \atop {\scriptstyle \overline{1} \rightarrow \overline{1},R} } &*++[o][F-]{S_4} \ar@(ur,dr)^{R} \ar[d]^{\overline{s} \rightarrow \overline{s},R} \\ &*++[o][F-]{S_5} \ar@(ul,dl)_{ {\scriptstyle \overline{0} \rightarrow \overline{0},R} \atop {\scriptstyle \overline{1} \rightarrow \overline{1},R} } \ar[r]^{0 \rightarrow \overline{0},L} \ar[dr]_{1 \rightarrow 1,L} &*++[o][F-]{S_7} \ar@(dl,dr)_{ {\scriptstyle \overline{0} \rightarrow \overline{0},L} \atop {\scriptstyle \overline{1} \rightarrow \overline{1},L} } \ar[u]^{\overline{s} \rightarrow \overline{s},L} &*++[o][F-]{S_6} \ar@(ur,dr)^{ {\scriptstyle \overline{0} \rightarrow \overline{0},R} \atop {\scriptstyle \overline{1} \rightarrow \overline{1},R} } \ar[l]_{1 \rightarrow \overline{1},L} \ar[dl]^{0 \rightarrow 0,L} \\ & &*++[o][F-]{S_9} \ar@(ur,dr)^{L} \ar@(dr,dl)^{{\scriptstyle \overline{0} \rightarrow 0,L} \atop {\scriptstyle \overline{1} \rightarrow 1,L}} \ar `l[ll]_{ \overline{S} \rightarrow S,R} `u[uuuu] [uuuu] \\ }
Thus our UTM so far looks like
\xymatrix { *++[][]{} \ar[r] &*++[F-]{Start} \ar[r]^{T \rightarrow T,R} \ar@(ur,ul)_{R} &*++[o][F-]{Hit \atop Tape} \ar[d]^{\Box \rightarrow \overline{s},L} \ar@(ur,ul)_{ {\scriptstyle s \rightarrow s,R} \atop {{\scriptstyle 0 \rightarrow 0,R} \atop {\scriptstyle 1 \rightarrow 1,R}} } \ar[r]^(.4){\overline{s} \rightarrow \overline{s},L} &*++[F-:<5pt>]{{Lookup\ New} \atop {Symbol}} \ar[r]{} &*++[F-:<5pt>]{{Write\ Symbol} \atop {on\ Tape}} \\ & &*++[F-:<5pt>]{{\scriptstyle Copy\ Blank} \atop {\scriptstyle Subroutine}} \ar `l[l] [ul]{}\\ }

Universal Turing Machines, Part 3: Initialization

Posted by Eric Hennigan
On June 23rd, 2007 at 00:06

Permalink | Trackback | Links In |

Leave a Comment |
Posted in Comp*

The first thing we do is scan the machines head all the way over to the Right end of the tape, stopping when we hit a s. If we accidentally scan too far and hit a $\Box$, then we’ll have to scan back and copy the designated blank symbol onto the end of the tape, and leave it marked with a s. Finally we’ll return the machine head back to the B, so that we can pick up where we left off.

In this manner we shall assure that a symbol is present on the tape when we go to look one up in the encoded transition function.

\xymatrix @!=3pc { *++++++++++++[][]{}\ar[dr]{} &*++[][]{ \txt{Copy Blank Symbol Subroutine}}\\ &*++[o][F-]{B_0} \ar[d]_{B \rightarrow B,R} \ar@(r,u)_{L}\\ &*++[o][F-]{B_1} \ar[dl]_{0 \rightarrow \overline{0},R} \ar[dr]^{1 \rightarrow \overline{1},R} \ar[r]^{{\scriptstyle Q \rightarrow Q,L} \atop {\scriptstyle \overline{Q} \rightarrow \overline{Q},L}} \ar@(ul,dl)_{R} &*++[o][F-]{B_2} \ar[r]^{B \rightarrow B,R} \ar@(ur,ul)_{{\scriptstyle\overline{0} \rightarrow 0,L} \atop {\scriptstyle\overline{1} \rightarrow 1,L} }& \\ *++[o][F-]{B_3} \ar[dr]_{\Box \rightarrow 0,L} \ar@(dl,ul)^{R} & &*++[o][F-]{B_4} \ar[dl]^{\Box \rightarrow 1,L} \ar@(dr,ur)_{R}\\ &*++[o][F-]{B_5} \ar[uu]^{{\scriptstyle\overline{0} \rightarrow \overline{0},R} \atop {\scriptstyle\overline{1} \rightarrow \overline{1},R}} \ar@(dl,dr)_{L}\\ }

Thus our UTM so far looks like
\xymatrix { *++[][]{} \ar[r] &*++[F-]{Start} \ar[r]^{T \rightarrow T,R} \ar@(ur,ul)_{R} &*++[o][F-]{Hit \atop Tape} \ar[d]^{\Box \rightarrow \overline{s},L} \ar@(ur,ul)_{ {\scriptstyle s \rightarrow s,R} \atop {{\scriptstyle 0 \rightarrow 0,R} \atop {\scriptstyle 1 \rightarrow 1,R}} } \ar[r]^(.4){\overline{s} \rightarrow \overline{s},L} &*++[F-:<5pt>]{{Lookup\ and} \atop {Copy\ New\ Symbol}} \\ & &*++[F-:<5pt>]{{\scriptstyle Copy\ Blank} \atop {\scriptstyle Subroutine}} \ar `l[l] [ul]{}\\ }

In all of our diagrams the notation $X \rightarrow Y,L$ means the machine will print a Y and move Left if it reads X on the tape. Since we have many symbols in our alphabet $0\ 1\ \overline{0}\ \overline{1}\ s\ \overline{s}\ q\ \overline{q}\ B\ T\ Q\ \overline{Q}\ S\ \overline{S}\ X\ Y\ \Box$ the shorthand notation L and R alone on a transition arrow will designate “scan that direction until one of the more interesting transitions occurs”, thus it does not imply nondeterminism. Pedantically it means $\{x \rightarrow x, Y\ |\ x$ is a letter of the alphabet that might be scanned $\}$.

Universal Turing Machines, Part 2: The encoding and overall design

Posted by Eric Hennigan
On June 20th, 2007 at 21:06

Permalink | Trackback | Links In |

Leave a Comment |
Posted in Comp*

The encoding for a machine with any number of states and any number of symbols:

Each state and each symbol will be numbered in binary, all the numbers must be padded to the same length. So, we can have symbols that number from 000 to 100, and states that number from 0010 to 1100.

Firstly, this UTM requires a register at the beginning of the tape that will be used for storing state information. Initially it can be filled with any number we want, as long as it is filled to the appropriate number of digits, and begins with a q.

q0000

Then we name the blank symbol. This can be any number, by convention, I’ve used the number 0. All symbols in the simulated machine must be padded to the same length. This symbol will be used to append to the tape every time the simulated machine tries to run off the right end of its tape.

B000

Then we specify the transition function for each symbol. qY and qX specify accept and reject states. The TM that recognizes (01)* is given by the transition table:
\begin{tabular}{c|ccc} &0&1&b\\ \hline $\boldsymbol{q_1}$&0,R,$\boldsymbol{q_2}$&1,R,reject&1,R,$\boldsymbol{q_3}$\\ $\boldsymbol{q_2}$&0,R,reject&1,R,$\boldsymbol{q_1}$&b,R,reject\\ $\boldsymbol{q_3}$&0,R,accept&1,R,accept&b,R,accept\\ \end{tabular}
Thus, if we use B11 for the blank, and number everything else normally, this table becomes the encoded string:

Q01 S00Rs00q10 S01Rs01qX S11Rs01q11
Q10 S00Rs00qX S01Rs01q01 S11Rs11qX
Q11 S00Rs00qY S01Rs01qY S11Rs11qY

After this comes the input tape, which we mark with a T, so for 010101 we would get:
Ts00s01s00s01s00s01

Bringing that all together, by removing spaces and putting in the register and blank symbol, we end up with:
q01B11Q01S11Rs01q11S00Rs00q10S01Rs01qXQ10S11Rs11qXS00Rs00qXS01Rs01q01Q11S11Rs11qYS00Rs00qYS01Rs01qYTs00s01s00s01s00s01
where the overlines indicate the starting symbol and the position on the simulated tape.

The general procedure will be to:

  1. check that a symbol ion the tape is marked, if not copy the blank symbol onto the end, and make it the current symbol.
  2. find the part of the state diagram that corresponds to the symbol on the tape.
  3. update the symbol on the tape
  4. move the tape left or right one symbol
  5. copy the transition state to the register, unless it’s a qY or qX in which case we can Halt on accept or reject.
  6. find the function definition that corresponds to the state in the register and mark it for the next step of simulation
  7. repeat

Universal Turing Machines, Part 1: The Journey Begins.

Posted by Eric Hennigan
On June 19th, 2007 at 22:06

Permalink | Trackback | Links In |

Leave a Comment |
Posted in Comp*

This past weekend I spent some time working with Turing Machines. More specifically, I implemented a busy beaver machine. After that I worked on getting Ullman and Hopcroft’s UTM to simulate the machine that recognizes (01)* with input 010101.

I came no nearer understanding how Ullman and Hopcroft’s machine worked after a successful run, so I’ve decided to design my own. I’m also going to fix up the UTM encoding so that it’ll be easier to generate the input, and so that it’ll naturally simulate machines with an arbitrary number of states and tape symbols.

a Busy Beaver machine: code output
TM for (01)*: code output
Ullman and Hopcroft’s UTM: code output

Workin’ for the Man

Posted by Eric Hennigan
On June 15th, 2007 at 00:06

Permalink | Trackback | Links In |

Leave a Comment |
Posted in Comp*, Idiocracy, Self

This last week, I showed what I’ve been working on for the last 7 months to my superior, only to be shot down. I’m responsible for ‘porting’ (really, it’s a complete rewrite) a Geospatial Information program from M$ windows to a custom in-house version of Linux. I modified the interface along the way, because I felt the current one sucks balls ( esp. with respect to some newer features ), it’s more of a kludge, and upon inspecting it’s code I’m surprised that it runs as reliably as it does ( full of memory sharing side-effect functions ).

So the reason I get shot down: “We don’t want to retrain all the current users.” Given the officialdom methodology and bureaucracy that we all have to deal with, I can understand. Still, it eats at my soul to purposefully make a decent application worse. I’m of the opinion that if the user requires to go through a complicated training course just to use the software, then either 1. the users are idiots or 2. the software has failed in some way. I’m leaning towards 2, because all software should work intuitively, following The Principle of Least Surprise, and require minimal to no training. I felt that the newer interface was nearer achieving that than the current one.

I was just trying to make the world a better place in what little way I can, but the Man just won’t have it. Mostly my disgruntlement stems from the fact that I’m growing tired of working on the same stuff for 7 months now. I’ve stopped learning about Qt/C++, and have settled into ordinary usage. It’s time for me to complete my project and move on to something else, something new, something where I can learn again.

I’m considering moving my mental energies towards stock market prediction, agent programming in erlang, SQL programming for metadata of geospatial imagery at work, or working on my Linguistic Engineering.

Linguistic Engineering

Posted by Eric Hennigan
On June 11th, 2007 at 22:06

Permalink | Trackback | Links In |

Leave a Comment |
Posted in Comp*, Language, Strange Loop

I’m going to found the field of Linguistic Engineering. I wish to study the relationship between what people think (algorithms) and what they say (programs), with the end goal being a set of design principles for the creation of programming languages for specific problem domains (ex. parallel computation and quantum computation ). This subject has some rather interesting ties in other fields.


  • Mathematical and algorithmic education. The construction of programs and the languages they are expressed in influence they way in which we think about programming. We need elegant, yet nonrestrictive notations for our programs, and these will correlate strongly with how the human brain functions.
  • Artificial Intelligence. The representation of knowledge strongly influences the ease with which certain types of logical inference can be deduced. The organization of knowledge within a cognitive system subjects the system to calculational constraints.

Next Page »