19 replies to this topic

[icuurd12b42]

Quantum Octree Computing...

Discuss

[Noah Semonchick]

What the hell is that?

[icuurd12b42]

What the hell is that?

I dont know; maybe I meant...
Quadrant Quadtree Computing?

Edited by icuurd12b42, 22 August 2012 - 03:12 AM.
double check

[xshortguy]

Octrees sound like a way to do simple "bit"-like collision engines.

[djk164]

it is a way of computing!!!! :D
i am probably horribly wrong.

[icuurd12b42]

Octrees/quadtrees is a process of recursive subdivision resulting in a fractal like positional referencing system. The number of division is infinite in real math but the number of division on a standard computer is defined by the size of the largest type you can do arithmetic on. Even on a PC a limited number of sub division can approach the quantic scale. 1/8 16 times = 3.552e-15

In a 64 bit number, like the __int64, you can store a byte by quadrant division. there are 8 quadrant possible in an octree division. each quadrant can have the value 0 to 7. a byte at quadrant 0123 is located from middle of world, upper right quadrant's upper left's lower left's lower right. Storing each quadrant reference takes 4 bits and would allow for 16 division on the octree world. 64/4 = 16

If the WORLD is a block of silicone. and at 16 division you find a byte (or more of the possibility of a byte), a memory block would need to be
281474976710656 bytes.... 256 terabytes.

Of course in today's limited PC architecture, this is not possible unless the memory is de-referenced by an octree overlay on top of the current (linear?) random access memory system of a PC. This is possible since an octree world does not actually take 256 terabytes but has the potential to need 256 terabytes. If there is 1 byte item in the octree world, this item only takes 1 byte of memory.

The octree can also define a 3d position for the byte if you specify the initial size of the world as something concrete. 0123 would occupy a region at x,y,z with the region size of total-size/8/8/8/8 if it was an actual cube (it don't need to be represented as such);

Now a byte can have a physical location in both memory and visual environment.

Now change the byte to some code that only runs when the octree location it's in is active, like say is visible by a process...Say the process is a camera that sees a an octree region. and that region has 100 items to render/update. In all the objects in the worlds, only 100 items are processed.


But what of the other objects in the world that needs to run each step? if we only run the code for what is needed now, what happens when you change location in the octree and activate those objects there.

Well, if you define the object as being time stepable, that is their state depends on a time value. Then the simulation can be updated only as needed, like when drawn.

for example

class Grass
{
    function OnCreate()
    {
        Time timeCreated = GetCurrentTime();
    }
    function OnDraw()
    {
        Time DeltaT = GetCurrentTime() - timeCreated;
        if(DeltaT > 30 days) drawGrass();
        else if(DeltaT > 10 days) drawFreshGrass();
        else if(DeltaT > 4 days) drawSprouts();
        else drawSseeds();
    }
}

An application Like say MS Word could reside in a Octree based memory scheme where the face of the application (it's window pixels) would be physical location with visual properties in the octree and the code itself would be behind it.

Octrees sound like a way to do simple "bit"-like collision engines.

For a point to point collision system, you can store the quadrant address 01234567 as your aabb system
You can sort the instances of those point by that address. Then proceed with a linear scan of the sorted array and perform the collision for each neighboring point in the array that has the same address.
sort address
for start = each instance 0 to n
for next = each instance start+1 to n
if(start.aabb == next.aabb) collision(start,next)
else break;

for items that have volume it's a little more complicated

[chance]

So what's this topic about? Is the title a mistake, or is there some element of quantum computing here? I don't see any discussion of quantum phenomena like state superposition or entanglement.

Sounds like "bait and switch" advertising.

[icuurd12b42]

So what's this topic about? Is the title a mistake, or is there some element of quantum computing here? I don't see any discussion of quantum phenomena like state superposition or entanglement.

Sounds like "bait and switch" advertising. :tongue:

There are already quantum computers that emulate quantum mechanics rules. The question is can we put qbit emulator(s) in a octree system where as the further in you dig in the octree fractal, the more exact the emulation is.

[chance]

So what's this topic about? Is the title a mistake, or is there some element of quantum computing here? I don't see any discussion of quantum phenomena like state superposition or entanglement.

Sounds like "bait and switch" advertising.

The question is can we put qbit emulator(s) in a octree system where as the further in you dig in the octree fractal, the more exact the emulation is.

That's the question? You haven't mentioned it before now. But QC simulators are an interesting topic in computer science. So let's get into that.

I've seen references to some that use a quadtree storage format. But I don't know what you mean by "the further in you dig in the octree fractal, the more exact the emulation is." A fractal structure should look the same at different scales. So "digging further in" doesn't make sense to me. Are you talking about "boundary effects" associated with the starting level?

And secondly, what metric are you using to measure how "exact" the emulation is? Not sure what that means.

[icuurd12b42]

Where as each octree or quadtree division can hold the same code as the parent node to execute with perhaps a variant or a bias, whatever the quattree quadrant code does is optional... and where the parent node has an approximation of the subdivision (node). Visually, an octree with the cell divisions running code to generate a Mandelbrot, the approximation for a Mandelbrot as 0 division would be a black square. At division 8, it would be what you are familiar seeing from a Mandelbrot image.

The fractal nature of the system is not the Mandelbrot but the octree system itself, infinite division by 8 is the fractal nature of the octree... by 4 for the quadtree. You can write an octree explorer code to be biased towards following a pattern in the data, say follow red blotches in the Mandelbrot.

The Quantum Computer setup what function the hardware will emulate and the code that makes this information useful is the data navigator that navigates, with bias, the data...

[chance]

The fractal nature of the system is not the Mandelbrot but the octree system itself...
<...>
The Quantum Computer setup what function the hardware will emulate and the code that makes this information useful is the data navigator that navigates, with bias, the data...

I understand the fractal-like nature of recursively sub-divided spaces. That wasn't my question. My question was what exactly you meant by "digging deeper into the fractal makes the emulation more exact." (paraphrased)

That would make sense if you were (say) using an octree structure to model a physical 3D object. Or doing a finite-element analysis, where you could expand the sub-divisions in areas with small scale structure (or localized stresses). In those examples, yes -- digging deeper into the sub-divided space captures finer and finer (more exact) detail.

But this doesn't seem directly related to quantum computing or quantum algorithms based on how data are represented in those systems -- i.e. bits versus qubits.

I was hoping to have a discussion about that, so I could learn more about it. So... do we have a quantum computing expert in the house? Maybe yes... maybe no... maybe both simultaneously.

Edited by chance, 26 August 2012 - 06:38 PM.

[icuurd12b42]

The fractal nature of the system is not the Mandelbrot but the octree system itself...
<...>
The Quantum Computer setup what function the hardware will emulate and the code that makes this information useful is the data navigator that navigates, with bias, the data...

I understand the fractal-like nature of recursively sub-divided spaces. That wasn't my question. My question was what exactly you meant by "digging deeper into the fractal makes the emulation more exact." (paraphrased)

That would make sense if you were (say) using an octree structure to model a physical 3D object. Or doing a finite-element analysis, where you could expand the sub-divisions in areas with small scale structure (or localized stresses). In those examples, yes -- digging deeper into the sub-divided space captures finer and finer (more exact) detail.

There, I believe you just answered it.

But this doesn't seem directly related to quantum computing or quantum algorithms based on how data are represented in those systems -- i.e. bits versus qubits.

the qbit emulator code resides in each octree division(s), in the same way that 3d model voxel does. Instead of representing a color block, the data is the most probable value of the qbit at that level. expand that qbit and now you have 8 qbits, each with its most probable value. qbit sub division, like splitting the atom, what lies beneath... nothing but probabilities that need to be extrapolated by the search algorithm... the octree navigator.


It's a little complicated because 1) your octree cell code has to be setup to emulate something defined by physicists to be an approximation of how things are supposed to work... 2) The software that looks at the octree data has to have some idea of what to look for in the data perhaps guided by weight.

Here is an example
you define you cell code as a string and as simply adding a random character when created.

Level 0, one cell is created with the character t. and the division will hold t+another random character, say to, ta, tu, ta, to, to, ti, ti

Level 0 would be represented as t with "to" being the high probability. Your navigating software wants to find English words and those words need to be grammatically correct when assembled, the searching code is governed by rules, so it detected "to" to be the start of valid English worlds. so it enters to level1 and then goes in one of the cells that has a "to" in it. Or it simply nukes the octree and regenerates the top level to have "to" as a seed for the subdivision. Next, the 8 sell have "to ", tot, toa, and so one. all of these could potential be a real word, but 'to ' has a space in it an is a real world.... Iterating though the the octree, or regenerating it with the right seed, the searching software will eventually find a sentence that makes sense.

That is starting from level0 with cells generating pure random values each expantion. the cell function can be more specific an biased. A cell could be aware of neighboring cells at its level and use those in it's function. Not obligated to start at level0, you can populate octree cells as deep as need be with initial data of a simulation.

For example, fill an octree with temperature and air density for the entire north American continent. some values could be from towns, other could be from the a state and since this is made by an American, Canada only has one useable value for the entire country.

Running the simulation, the smallest octree divisions would be more accurate at simulating the local weather, and affect more accurately the parent representation. were as you would only get a guestimate for Canada and it's neighbor American states.

Your search software would look for signs of tornadoes in the simulation where as each cell code would simulate from the data it has and the condition of it's neighbors the weather at that level.

Now to me, it's fractal because it is subdivision, it is quantum-like because the data represented (quanta) is still dividable to the limit of the computer, said limit would be defined as the octree plank scale.

I was hoping to have a discussion about that, so I could learn more about it. So... do we have a quantum computing expert in the house? Maybe yes... maybe no... maybe both simultaneously. :tongue:

I believe we both are...not... maybe.

[chance]

But this doesn't seem directly related to quantum computing or quantum algorithms based on how data are represented in those systems -- i.e. bits versus qubits

<snip>
For example, fill an octree with temperature and air density for the entire north American continent. some values could be from towns, other could be from the a state and since this is made by an American, Canada only has one useable value for the entire country.

Running the simulation, the smallest octree divisions would be more accurate at simulating the local weather, and affect more accurately the parent representation. were as you would only get a guestimate for Canada and it's neighbor American states.

Your search software would look for signs of tornadoes in the simulation where as each cell code would simulate from the data it has and the condition of it's neighbors the weather at that level.

Now to me, it's fractal because it is subdivision, it is quantum-like because the data represented (quanta) is still dividable to the limit of the computer, said limit would be defined as the octree plank scale.

You're combining various aspects of quadtree spatial indexing, recursive fractals, and a little cellular automata thrown in.

What you're describing are tradition deterministic algorithms, but ordered in an octree-like spatial structure. Algorithms act locally on their own particular (quantized) spatial scale. That's often how continuous 3D space is represented in computer and finite-element simulations. But there's nothing quantum mechanical about it, at least not in the usual sense that includes superposition of states.

Nevertheless, it's an interesting concept for doing numerical simulations of 3D phenomena. Many FEM software packages I've seen have a feature where they'll flag certain spatial regions as requiring finer-scale sub-divisions. It's usually based on some metric the user can select -- like a stress gradient, or the slew rate of some localized variable. Then the software will automatically sub-divide that particular region further, and repeat the calculation.

Edited by chance, 27 August 2012 - 11:41 AM.

[icuurd12b42]

Well, we did go towards the quantum physics based on your idea. I never said quantum [physics/mechanic] octree computing

quan·tum/ˈkwäntəm/
Noun:

1) A discrete quantity of energy proportional in magnitude to the frequency of the radiation it represents.
or
2) An analogous discrete amount of any other physical quantity, such as momentum or electric charge.

Where as "An analogous discrete amount of any other physical quantity" is the function of the octree cell code or data


It is as you said, an interesting concept whatever is the proper terminology.

[chance]

Well, we did go towards the quantum physics based on your idea. I never said quantum [physics/mechanic] octree computing

quan·tum/ˈkwäntəm/
Noun:
<snip>

No need to define "quantum". But numerical simulations that employ discretization to represent continuous various aren't inherently "quantum mechanical". I know you understand the difference, so I won't belabor the fact that you're over-reaching here.

Either way, have you used your octree methods to perform any calculations? I'd be interested to hear about them.

Personally, I'm interested in cellular automata approaches to simulating physical processes, although I haven't had much success doing it. But plenty of fun trying.

[icuurd12b42]

I am hopeful someone will try this at one point. Perhaps I will in a few years. right now I'm busy with a game I'm working on. this topic is just a way to take an intellectual break from it.


One thing I was asking myself is what if they would change the PC architecture to support this natively. Where as each cell or combination of neighboring cells is a program and associated memory placed in the silicone block in a octree fashion...

What if a PC would become just a large block of silicone where the code and data is executed at the location it resides. Instead of loading a program in the cpu for it to run you would simply activate the region it is located in, aka the octree navigating software is more of a virtual PC being able to move through the octree and execute the programs located in the region is encompasses... I'm thinking of a way to merge live data, processing and storage in one single block of silicone.

The silicone block could be shaped to improve cooling with air. In the form of fins, for example. Processes that cause heating of the material could be moved to the edges closer to the surface of the block in a place in the shape that cools down more efficiently.

[chance]

One thing I was asking myself is what if they would change the PC architecture to support this natively. Where as each cell or combination of neighboring cells is a program and associated memory placed in the silicone block in a octree fashion...

What if a PC would become just a large block of silicone where the code and data is executed at the location it resides.

Interesting concept... but I don't see any obvious advantage of the "literal" block design. It doesn't seem necessary -- or even desirable -- to physically replicate the block analogy in silicon to achieve the features of quadtree-like design.

Practical issues of manufacturability must take precedence. You could achieve similar design features by "unfolding" the block into a network of flat planetary patterns. For example, one could envision 4-8 primary processors with each one connecting locally to its own planetary system of (say) 4 secondary processors, and each with its own dedicated memory.

This design allows each processor and memory group to sit atop a shared power grid and shared data bus, with easier access to a common clock. Processor interconnections might be slightly longer with the unfolded design, but manufacturing things like cooling, power distribution, timing control, etc. would be much easier. And the unfolded design also allows practical limitations of individual circuit elements to be addressed more easily -- namely width, spacing and enclosure integrity.

Lke I said, the octree-like design is interesting, and might have advantages. But it's probably better to keep the "3D block analogy" as a conceptual overlay.

EDIT: clarity

Edited by chance, 28 August 2012 - 12:43 PM.

[icuurd12b42]

Yeah, I hinted at the overlay in post 4. I would like to do away (not throw away, still useful for higher level function) with the concept of physical processors in favor of nano processing cells with limited function. where as today, a memory cell has read, write ability, this new type cell would have a read, write, set code, run code (perhaps on a run code clock) The run code clock sends a pulse in all cells in parallel. so they all run the code at the same time and execute the few instructions for each cell.

Where as today, a single byte occupies an address, in that system you would find a byte and some extra for the code... say a few dozen bytes, enough to implement a micro cellular function. Of course this mean the new memory type would be much larger is physical size.

Where as you presently make a computer using cellular automata, you could, in theory do the same at that level
http://www.quinapalu...m/wi-index.html

hey look what I found looking for above
http://www.ncbi.nlm....pubmed/12908262

[chance]

I would like to do away (not throw away, still useful for higher level function) with the concept of physical processors in favor of nano processing cells with limited function. where as today, a memory cell has read, write ability, this new type cell would have a read, write, set code, run code (perhaps on a run code clock) The run code clock sends a pulse in all cells in parallel. so they all run the code at the same time and execute the few instructions for each cell.

These cellular-based designs are fun to think about. But I haven't seen much about using them for "general purpose" calculations -- i.e., everyday applications like word processing, game playing, photo editing, CAD, etc..

Instead, the applications are always highly specialized -- such as cellular automata simulations, or maybe prime number sieves.

I don't believe that's a fundamental limitation of cellular designs -- but it certainly changes the way we write and compile code. Today's languages are generally designed for traditional one-step-at-a-time algorithms. And although there are compilers designed to take advantage of parallel architectures, none quite handle the highly parallel nature of cellular designs.

So that's a challenge.

Edited by chance, 29 August 2012 - 12:35 PM.

[icuurd12b42]

I can imagine a compiler that translates code to cellular automata output would be quite the task