A (Fractal) Theory Of Everything?

[Gary Gaulin]

Kram, there is no doubt that you are way beyond average knowledge in robotics and the properties of intelligence!  And discovered how applications for what I have been describing are so numerous it's hard to decide where to begin.  Where there is just one starting point, the project is easy to get started.  Where there are hundreds or more that would all probably work it can become overwhelming.

I proposed a "theory of everything" since that helps narrow down a field of possiblities that gets wider and more complicated to code as complexity (emergent level) of what is modeled increases.  Modeling atoms would be starting point 0 where all else above it is theoretically emergent from that alone.  Can then save fully trained atom-bot memories, that sum up to molecule-bot memories that only need one per molecule type instead of one for each molecule in the model.  Can then sum up each molecule to make organelles.  Then sum up each organelle to make cells.  Then sum cell to make multicellular organisms.  Even where it's still probably impossible to fit a human into a PC it would still be the most awesome computer model ever.

Since you do not code your own programs yet it would be possible to add to the particle-bot program a way to experiment with their behavior.  Possibly a window that comes on the screen when you push a command button to enter and save the conditional If..Then.. statements the program will use.  Can also have it load the last memory you saved so that it does not have to start from scratch each time.  Also be nice to have three types of memories/entities so there can be the elementary particles; electrons, neutrons and protons.  Once the behavior is similar to real atoms we can see what is emergent from them by adding a way to sum up entity types to share the same memory.

[kram1032]

That would be like adding new goals over time.

You pause the program to add new conditions and go on That sounds nice

[Gary Gaulin]

I'm not rushing into recoding the program, but after thinking about a way for others to experiment with it I got to thinking about the free MASM32 compiler:
 
http://www.masm32.com/
 
Since it directly codes the instructions that the CPU itself runs on, assembler language is the fastest executing code there is.  And there are not a large number of commands to learn.  Or is it something that becomes obsolete, it's a free download because at the CPU level what worked years ago to code it with still works as well now.  Should be able to write in multi-core features, with codes that would be in the CPU documentation for them that Intel should have online.  But no rush there, first need to get something running.
 
I downloaded then reinstalled it without too much difficulty except for the MacAfee Anti-Virus having to be turned off for 1/2 hour for the reason they explained in the install program then had to delete the MASM32 folder it made but was not allowed to install files into.  Looked like it's using memory like crazy but was just unpacking example programs.  Once finished there is information on what to do next to get started that I printed out.  Also makes an icon on your desktop for an editor that has an "Introduction To Assembler" in it that is not very long.  Briefly explains how the CPU works so you know what the instructions in the example programs are doing.
 
There are a good number of example ".asm" programs (that compile to ".exe" files) that make slider controls, listboxes, zoomable bitmap grid, message boxes, and all else needed to build a better bot or even fast fractal software.  Just skip "qexit.exe" unless you want to find out the hard way (like I did) that it turns off your computer.  The "tutorial" examples and maybe others seem to be for DOS mode but most worked fine with windows.
 
 
It does not seem worthwhile to recode any of the programs that I now have, so I made another attempt at using the Schrodinger's Equation that years ago I had drawing orbits but the theory behind each variable was relatively mysterious. I'm now thinking that it might be better to organize waves that are each somehow one step amounting to a complete trip around an orbital.  After there is one electron in each subshell they must pair up oppositely and opposite orbital direction to cancel out each others wave (remain stable) or else like forces will repel sending the wave flying out of the atom.  And there are photons to account for that are part of Shrodinger's Equation.  Details of their trajectory are here:

http://physics.bu.edu/~duffy/py106/PhotoelectricEffect.html

That brought me back to the physics "Particle In A Box" equation, which is the simplest Schrodinger Equation that there is.  Here's a good lecture on it in case you or anyone needs it.
 
<a href="http://www.youtube.com/v/f-ibK6TMf7k&rel=1&fs=1&hd=1" target="_blank">http://www.youtube.com/v/f-ibK6TMf7k&rel=1&fs=1&hd=1</a>
 
And here's a real challenging lecture on the Schrodinger's Equation (jumpy image but still good info) that starts off by explaining the wave-like properties of the elementary particles, that are hard to account for in a model:
 
<a href="http://www.youtube.com/v/2ejyr-E7q2M&rel=1&fs=1&hd=1" target="_blank">http://www.youtube.com/v/2ejyr-E7q2M&rel=1&fs=1&hd=1</a>

Also have a short animation showing some of the things atoms do together.
 
<a href="http://www.youtube.com/v/DrGRTtdJgoo&rel=1&fs=1&hd=1" target="_blank">http://www.youtube.com/v/DrGRTtdJgoo&rel=1&fs=1&hd=1</a>
 
It looks like there is no easy way out of the math of this problem.  But it's looking easier all the time so that's a good sign!

[David Makin]

Hi all, those of you interested in this thread will definitely be interested in the end section of this BBC program:

http://www.fractalforums.com/fractal-related-links/chaosplusfractalsbbc-tv-limited-availability/msg11706/#msg11706

[Gary Gaulin]

And just in case the math is still not making sense of the problem here are several relatively short "Common Sense Quantum Mechanics" videos to explain an intuitive way to visualize the concepts for making models and such that uses pins/arrows going through wires to account for polarization of light.  Very low budget but he does an excellent job of explaining things:
 
<a href="http://www.youtube.com/v/SYzFC-nxy9I&rel=1&fs=1&hd=1" target="_blank">http://www.youtube.com/v/SYzFC-nxy9I&rel=1&fs=1&hd=1</a>
 
Another on polarization but does not demonstrate polarization:
 
<a href="http://www.youtube.com/v/0udtI6FTMa0&rel=1&fs=1&hd=1" target="_blank">http://www.youtube.com/v/0udtI6FTMa0&rel=1&fs=1&hd=1</a>
 
Then there is the one for the Schrodinger's Equation explained as spinning arrows.   
 
<a href="http://www.youtube.com/v/JmEMVJYbTu8&rel=1&fs=1&hd=1" target="_blank">http://www.youtube.com/v/JmEMVJYbTu8&rel=1&fs=1&hd=1</a>
 
Also Planck's Constant

<a href="http://www.youtube.com/v/LPQS9cF3C7s&rel=1&fs=1&hd=1" target="_blank">http://www.youtube.com/v/LPQS9cF3C7s&rel=1&fs=1&hd=1</a>

Wave travel can be broken down to a number of degrees at a time so that we can see it.  But a real particle that is also like a wave would seem to be a bot that is also a self-powered rotating needle that turns 360 degrees per one Planck's Constant energy unit step.  With there being no need for motors, all data and addressing of the self-learning memory system would then sense and control direction of travel around what we might visualize as curved space/time around atomic nuclei.

[Gary Gaulin]

Hi all, those of you interested in this thread will definitely be interested in the end section of this BBC program:

Hi David, thanks for the video! I just played it, was a big help seeing how the tree fractal fit into things.  Helped show how fractals and the physics are related.   And with all the physics video's I posted that was a good break from the heavy math that is in that science.

[kram1032]

So, you're going to code a new botparticle-style program but this time with the schrödinger-equation?

[David Makin]

So, you're going to code a new botparticle-style program but this time with the schrödinger-equation?

You can't possibly do that - the program will only exist when you're viewing it

[kram1032]

haha, yeah xD

Well, just let it run for a year, look at it and pure quantum randomness will have done its job xD
Instead of particles, you'll see clouds of particle-finding-probabilities


Thanks for the video-link, david The last thing perfectly drew the relations of fractals and intelligence and besides featured a very nice application

[Timeroot]

So, you're going to code a new botparticle-style program but this time with the schrödinger-equation?

You can't possibly do that - the program will only exist when you're viewing it

Even worse, it wouldn't necessarily begin to exist at that point. It could just as easily not exist; since it is constantly interacting with you computer, or at least parts of it, couldn't your CPU just go *poof*?

[Gary Gaulin]

So, you're going to code a new botparticle-style program but this time with the schrödinger-equation?

I have to make sure to also work on what might help pay growing bills but that would certainly help achieve realistic particle behavior, in the least amount of time.  But thankfully studying how the Schrodinger Equation works established a needed X,Y with rotation coordinate axis system for the CrossCut algorithm.  I found out that it has the same set of rotations that are needed for that algorithm even the "phase" angle I was trying to explain that does the exact same thing which here makes the spinning (while cutting a spiral) crosscuts the spinning needles!  Not following a tried and proven system that works exactly one that already has names for each thing led to confusion while reinventing that wheel which led to a mess that one way or another had to be straightened out before I wasted even more time renaming variables and guessing which way things should rotate with the rest of the system.  Another case of "learning how they do it" ending up saving me time in the long run, and I think I'm almost there as far as truly understanding it all.
 
What really speeded things up is that Arjen (common sense quantum physicist) wrote me back and included this link to something they wrote that's very very good:
 
http://en.wikiversity.org/wiki/Making_sense_of_quantum_mechanics/Principles_of_Quantum_Mechanics
 
I'm now "taking notes" and am putting them into a shell program (where the existing crosscut and particle-bot code later gets put inside) where I can test the new math system to make sure it's all working before recoding other software to work that way.  Will give me a chance to try out what Arjen explained without neglecting work-work that I am also committed to finishing in the least amount of time.  Problem is though, that work connected to fractals that connected to Schrodinger's equation that connects to the particle bots for displaying that behavior that connects back to the CrossCut program that needs the exact same math or it will remain a programmers nightmare to properly structure.  Might even say that in this case the CrossCut algorithm not having things the way they are in math/physics makes it somewhat amateurish.  So there is no easy way out, no matter what I do.
 
With it now being much easier to apply the math to the particle-bot problem than it is to the CrossCut algorithm I will first try to figure out how Schrodinger's equation relates to that.  From what I can see it is simply a matter of adjusting confidence upward by 1 when a particle moves to where there is a higher probability of finding it, else confidence is reduced by one.  Schrodinger's looks well suited for controlling something like that until it is trained, but seems very poorly suited for directly modeling from due to there being so much number crunching required to keep the model moving and probabilities a fuzzy logic that as the name suggests is hard to get a clear picture from.  It's too early to say whether the particle-bot idea would work but where it's hooked in correctly it should do something interesting.
 
I can just as easily (or even more easily) test the math by as soon as possible adding Schrodinger's to the existing particle-program where electrons leave a trail behind that can be made as long as we want and other things.  Would otherwise need some way to see it from all angles and in action, no sense in adding that to the shell program when what might show them even better and faster is already there.
 
Only drawback is in needing to figure out an easy way to get something that works right away so it does not end up stretching on for days then weeks.  One idea I had is to make a small enough 3D world environment where the X,Y,Z of each particle relative to nuclei is simply and easily added to addressing.  Now only need a sense of everyhing else  The behavior gained from Schrodinger's equation should make the lines (sort of speak) on the gridlike environment fall on Fourier Transform intervals (a curve is already in it) but with a program it's much easier to draw a straight line from point to point.

Also, there is a "State Vector" (energy E, position r, momentum p) that seems to belong in addressing.  And it will need a way to sense other particles, but will better know what is needed when I finish figuring out all of the new information from Arjen.  They sure are making a hard concept easy to figure out, and I sure appreciate the help.

So, you're going to code a new botparticle-style program but this time with the schrödinger-equation?

You can't possibly do that - the program will only exist when you're viewing it

Even worse, it wouldn't necessarily begin to exist at that point. It could just as easily not exist; since it is constantly interacting with you computer, or at least parts of it, couldn't your CPU just go *poof*?

With what I had to endure like that (but for real) in other forums I better not even get started on a tangent in that direction!  The wrong "i" word in the wrong place really can get one henpecked over nothing for mentioning it.  Which is why I'm glad that there are forums like this one where what I say can be understood, or for the most part anyway. 

[kram1032]

If I got you right, you're first trying to do the 2D-Version and then the 3D-one but the 3D-one will be EASIER than the 2D-one? O.o

That would be more than rare xD

You said, you need an all-side view...
Coulnd't you just add 6 (smaller) static views of the rotating cube and let the 7th be the rotating cube as always?
Maybe give each cube-face a different colour, so you can easily see on the spinning one, which side of the fixed ones is where

But I'd highly recommend you to learn OpenGL, get some OpenCL-enabled graphics card (so, any modern nVidia, afaik - no need for it to be too expensive), and learn that too

As soon as you know those two, you'll surely benefit on both your single programs (for vastly decreased calculation times) and on your job's side (if you're a programmer, at least...)

[Gary Gaulin]

If I got you right, you're first trying to do the 2D-Version and then the 3D-one but the 3D-one will be EASIER than the 2D-one? O.o

Actually there are probably a couple hundred different ways to use Schrodinger's equation, depending on variables that are given and what is to be drawn.  Can also be implemented using matrix math.  One method first calculates the time-independent equation then uses that result to calculate time-dependant units.
 
Going from 2D to 3D is easy.  Getting else just right is the hard part.  And in this case the computer model already has a coordinate system like in the equation, just needs the rest of Schrodinger's added to it. 
 

You said, you need an all-side view...
Coulnd't you just add 6 (smaller) static views of the rotating cube and let the 7th be the rotating cube as always?
Maybe give each cube-face a different colour, so you can easily see on the spinning one, which side of the fixed ones is where

Usually when I need a quick view from 3 sides I make 3 pictureboxes then draw (x,y), (x,z), (y,z) but in this case it's already set to go with spherical shells.  Only had to include electron x,y,z in addressing, like I mentioned trying out.  Worked great.  Links below are for a download.


http://selflearningbots.blogspot.com/
http://sites.google.com/site/intelligenceprograms/Home/AtomSphere.zip?attredirects=0&d=1

Here is the code.  The math that produces the sphere is between the two ".####" lines that mark where it is:

Code:

'>>>>>>>>>>>>>>>>>>>>>>>> Main Intelligence Generation Loop <<<<<<<<<<<<<<<<<<<<<<<
Private Sub MainLoop()
Dim N As Long
Dim AngNum As Long
Dim Angle As Long
Dim R1, R2 As Double
   Xctr = WorldSizeScroll / 2
   WorldCtr = WorldCtr
   WorldSize = WorldSize
'This subroutine keeps looping back up here until EndMainLoop=True.
StartMainLoop:
      Frames = Frames + 1      'Count how many times Electrons were Moved for screen.
      AvConf = 0
'
'For each of the Electrons in the simulation (starting with number 1)
  For N = 1 To Electrons
      Call RunMotors(N)
'################################################
'Calculate Radius from center neuclei.
      X = WorldCtr - Xbot(N)
      Y = WorldCtr - Ybot(N)
      Z = WorldCtr - Zbot(N)
      R = Sqr((X ^ 2) + (Y ^ 2) + (Z ^ 2))
   If R < 0 Then R = -R
'Calculate positive distance from ideal Radius.
      R = R - 4
   If R < 0 Then R = -R
'Set the amount of Confidence Change, Success = 1 and Failure -1
   If R < EleCtrR(N) Or R < 0.501 Then CnfChange = 1 Else CnfChange = -1
'Save distance from ideal Radius for next step it makes.
          EleCtrR(N) = R
'################################################
'Adjust confidence in Memory, up or down.
      Cnf(N) = Cnf(N) + CnfChange
'Make sure it stays between 0 to 3.
   If Cnf(N) < 0 Then Cnf(N) = 0
   If Cnf(N) > 3 Then Cnf(N) = 3
'Save Confidence in the action it tried, in Main Memory.
      Call WriteMainMemory(N)
'Put together motor settings, wall bit, 2 angles, whether > 2, into one large number.
      Call FormMemoryAddress(N)
'Set bot motors and confidence level to what is found at that Addr.
      Call ReadMainMemory(N)
'Confidence = 0 causes the Random Guess motor response to happen.
CheckConfidence:
    If Cnf(N) = 0 Then
       Cnf(N) = 1
       Colr = vbGreen              'Change electron color to show new memory.
      Call RandomAction(N)         'Set Electrons Motor with random and moving.
      Call WriteMainMemory(N)      'Save new memory.
    End If
      AvConf = AvConf + Cnf(N)
      Cbot(N) = Colr
'Move next electron.
  Next N
'
      AvConf = AvConf / Electrons    'Subtract number of stationary so will reach 3
      AvConf2 = (AvConf2 * (1 - AvSm1)) + (AvConf * AvSm1)
      AvConfLabel = Format(AvConf, "0.0#####")
      AvConfLabel2 = Format(AvConf2, "0.0######")
'Let the Windows operating system handle new events, or mouse/keyboard stays ignored.
        DoEvents
'Check to see whether new events included setting EndMainLoop = True, to exit loop.
     If EndMainLoop = True Then
        MainLoopEnded = True
        Exit Sub
     End If
   Call Monitor
'Jump back up to start of loop, for next time step.
 GoTo StartMainLoop
'
End Sub

[kram1032]

Whoa, this seems to be a lot faster
Very nice

This looks good and seems to work

So this is using Schrödinger's Equations?

They learn the correct behaviour more or less instantly!

So, you should add more rules.
A sphere is the easiest and only exactly found solution of the Schrödinger Equations, after all...

Even in the biggest world-size with maximum amount of electrons, one gets 64 fps. That's a LOT faster than the same stuff in the previous version

Things to add:

protons and neutrons which need a virtual electron and a proton, quantum numbers (main, secondary, magnetic and spin) so electrons don't just all go into a single spherical orbit...

[kram1032]

Still alive, Gary?