Just riffing off some ideas I had earlier:
Matter and Anti-Matter. Think of these as 1’s and 0’s.
Quantum particles are the first layer of abstraction over the 1’s and 0’s.
Similar to logic gates in computers, or ATGC in DNA.
All these things have something in common — they store information.
The observer effect in quantum mechanics is an interesting problem.
As a starting point, we should think of everything in our universe as information.
Now think of a computer.
It’s showing a complex graphical / visual interface, based on ultimately the position of millions and billions of 1’s and 0’s.
In any particular instance, the CPU of your computer is storing / calculating a single, extremely long string of binary.
This unique string of binary moves up the fractal ladder (logic gates —> assembly language —> ruby —> rails —> etc.) until it creates the visual components by turning on your display.
For this example to move forward, lets say we have a word document open.
We can think of this state as a very specific binary code – all the information needed, in 1’s and 0’s, to be able load / boot / run the software, and launch the application.
Lets call the binary code of this state: 100000001
Now, imagine we let the computer go into standby mode. The screen goes black, and in order to make this change happen, the binary on the CPU needs to change a bit as well.
The code for the screensaver may only be 1 or 2 lines on top of millions of other lines of code — but it generates a completely different binary output on the CPU.
Even though the data is virtually 99.999% the same — the output binary on the CPU is completely different.
The binary code with screensaver is now 111100001.
Although fundamentally the same data — the system now needs to compensate for an observer.
We only made a very small change in the graphic interface — essentially going from sleep mode to awake, but we still had to run some code to make that happen.
Even though the states are extremely similar on the front-end, small changes in the math at the visual level get extrapolated when pushed through various systems back down to binary.
So — with the same data present in the background, the mere act of observing the information on that computer fundamentally changes the code that exists on the CPU.
Tacking this on to quantum mechanics — at the very small scale, the total amount of information in a system is extremely small, meaning small informational changes would logically show drastically different results.
The simple act of observing may add more information and complexity into the system, therefor altering it.
In order for this additional observer information to be calculated / compensated for , a slightly different outcome is achieved than when not observed.
If we think of everything as information — the simple act of watching something increases the information of that isolated system.
I look at game theory for some additional empirical evidence.
Nash equilbrium, in it’s basic terms, is an incentive algorithm that proposed optimized results for players in a game.
Nash’s novel idea was instead of Alex Smiths ‘every man for themselves’ being the optimized path to take — each person should consider all the other people in the game, in addition to their own incentives, to draw a new, optimized play.
Now this isn’t fully applicable to what were talking about, but something interesting pops out.
Systems are optimized when they consider all possible outcomes of a state.
Just like the nash equilibrium considers all the people in a game — natures systems likely optimize through a similar system.
Observing a system increases the amount of entropy in that system.
Entropy is the amount of disorder, or information in a system.
Adding a pair of eyes certainly increases the disorder and complexity of the situation.
Not to mention that those eyes are self-aware. This may add even more complexity to the system.
An ant seeing a quantum event may not have many implications — they don’t understand, therefore we would see a minimal ripple effect on the universe.
The possible paths for an ant seeing quantum physics is orders of magnitude smaller than all the possible informational paths for a human with understanding of a new idea.
When quantum particles are not observed, there is no additional information and objects can behave uninhibited.
When observed, we are essentially complicating the binary of the universe. Throwing in another variable to calculate.
It’s possible that the simple act of observing quantum mechanics would prove to be too much information for such a small system to handle.
The ripple effect from observing that type of interaction would be immense.
The universe would change. And if this is the case — it may not be possible for a system of such small and delicate nature to calculate such a large and impactful event as viewing / understanding the binary of our universe.
It’s a singularity paradox of sorts.
Everything unlocks at that point — and because of that — we literally can’t see it happen.
We can only guess / observe its outputs.
If everything is information, then the act of observing pure information would, by definition, increase the information of that system.
Pure information is not something we can ever actually see. We can know it’s there, and believe it’s there because of empirical evidence, but the singularity point will never be observed.
Imagine you’re a character in the online virtual world of 2nd life.
If those avatars suddenly became self-aware in their code, and worked for millions of years and finally understood the world of ‘sims’, they would find some interesting things.
The first layer of abstraction they would see would be words & code like </html></body> …. This is like humans finding math.
The avatars would eventually work backwards to figure out ruby, php, python, basic, and many other languages using emperical evidence to slowly build a archive of information (periodic table).
One day an avatar in 2nd life finds something really weird.
He gets down to the ‘bottom’ layer of abstraction. He learns all the codes sims people found are based on something much simpler — 1’s and 0’s.
He uses a 2nd-life computer to run a simulation of the 2nd life universe — he can actually calculate the binary that should be output.
The curious thing is, in all the simulations he runs, everything is fine — nothing comes out weird, all the code checks out.
But when he tries to actually look at the binary of his 2nd life universe, he can’t ever get the binary to match up to what it’s supposed to. It’s always a little off.
The thing he’s not seeing is that in-order for him to be able to ‘see’ the binary, he’s required to be present in the system. Since he’s ultimately just binary himself, — when he looks at binary the code, it instantly changes.
Not sure where I’m going with this, but it’s an interesting line of thinking.