EDIT:[
I spoke too soon about the "very approximate simulation of 4096 qubits" in how it would be very hard to use those qubits even though they appear to be there in the interactions of the waves in very very subtle ways, specificly that every physicmata object affects every other physicsmata object because its a network with cycles, and if you build a network of such objects as a more linear list, where each physicsmata connects to the few after it, then you see they do all affect eachother but very very slowly patterns appear to be echoing through the network possibly as a recursive carrier wave, but how to use that property is still a subject for future research. When you paint onto the screen, that is changing something mostly local, but its the nonlinear echos of it that I was talking about. When physicists say qubit, they're talking about something they can easily access. This can be seen in how it reacts to changes you make with the mouse after its already oscillating a certain way, but what I'm talking about is very very subtle.
The point of this all is to simulate gravitons, which I think are a physics operator derived from themself in a network with cycles. An example of a graviton is in the double-slit experiment on the circular path between where it splits in the past, goes through both slits, then takes different lengths of path to hit the back wall off center (instead of the sum of 2 bell curves from the individual slits). This can only happen at integer wavelengths relative to eachother because the paths from the 2 slits has to align to eachother where it hits, closing the timeless graviton loop. Such a path I call a graviton. That is what I'm trying to simulate, paths that form emergently at an integer number of oscillations, where oscillation is any self-referencing pattern that tends to form in random waves.
Still, based on what I've learned so far about fourier math, I think that investing in a global infrastructure based on the difficulty of factoring large integers is not a good gamble, and that is not my research path, just something that many people are interested in a near research path, and these kind of things are what usually drives changes, not science by itself.
]
I don't know. I work mostly by intuition.
I had thought when I was building Physicsmata (now version 0.6.0 you can get on sourceforge, GNU GPL open source, very small algorithm) that it is exclusively a kind of "fuzzy-encryption" the kind you find in black holes so various "universes" each with their own variations of wave-based physics can exist mostly independently of others through time-dilation, as I've explained other places.
https://sourceforge.net/projects/physicsmataI am almost certain whats on sourceforge now, and what I've described other places, is a very approximate simulation of 4096 qubits in a relativistic dimensionless manifold.
It is not my intention to change anything at the level of such global conflicts, but instead to get to the root of such conflicts, how physics and brains work, for example. I have done this, and the truth scares those whose power comes from enforcement of ignorance.
In any case, this very simple (only a few lines of code, the rest is for displaying it in the window and mouse controls) algorithm is the laws of physics, and simulations of physics are not subject to regulation regardless of what powers a quantum computer has and can be simulated, theoretically.
Just an intuition, which should be taken as serious as the existing simulation is serious about timeless dimensionless manifolds, that I wouldn't invest in any global infrastructure based on the difficulty of factoring large integers.
I won't be using any large integers toward such purposes, but nobody owns the laws of physics, and if others choose to pursue that path of math, anyone who would hold back pure research of numbers has become more of a problem than they're worth as billions of people may start to see that way.
Go burn a math book.
In case they get any ideas about burning math books, I'll be spreading this a few places
/** Ben F Rayfield offers Physicsmata under GNU GPL open source license(s),
previous versions included modified fast fourier transform from Paul Falstad's
educational applets, with his permission for GPL, but I don't think theres
much need for the direct form of fourier math anymore as I've completely made
it decentralized between the Physicsmata objects which keep complex weights about eachother.
Theres not even any reshaping of the network and it still simulates many
kinds of waves which conserve momentum, created by your mouse movements
in a grid of pixel Physicsmata objects that don't know which pixels are near
which others.
*/
package physicsmata;
//TODO import humanainet.Symbol;
/** A Physicsmata is a unit of cellular automata, a pattern-matching liquid
in unlimited dimensions which fit together and calculate in terms of sparse
high dimensional fourier transform, calculations of the phase and amplitude
at various angles and positions on that hypersphere.
<br><br>
The network of Physicsmata has cycles so lossy-compression can be done fractally
and from many angles at once. Lossy-compression is how the waves on the unlimited
dimensional hypersphere flow together into patterns as the phase and amplitude
of various position and angle alignments of fourier transform are gradually
changed to align to eachother in near Physicsmata. This is fuzzy network routing
where the network is between trillions of Physicsmata objects across the Internet.
<br><br>
TODO implement n-dimensional time manifolds, where time is any variety of entropy,
instead of only having phase change in 1 direction of time. This can be done by
using Physicsmata in networks with cycles and interpreting phase as a function
of that network shape from where you're viewing it. In some ways it will do
this even with this simple design I'm starting with, but it can be done in
more advanced ways in later versions.
<br><br>
TODO should Physicsmata be an interface instead of class?
*/
public class Physicsmata{
/** changes in nextState depending on what Physicsmata this Physicsmata is connected to *
protected Complex phase;
Instead, as an int, it automatically wraps around a range of 2^32, which will be interpreted as 2*pi.
*
public int phase;
Phase must have radius 1.
*/
protected Complex phase;
/** quantity of peers */
protected int size;
public int size(){ return size; }
protected Physicsmata peers[] = new Physicsmata[64];
protected Complex peerMult[] = new Complex[peers.length];
public void add(Physicsmata p){
if(p == this || indexOf(p) != -1) return;
peers[size] = p;
peerMult[size] = new Complex(.5, .5).norm();
size++;
}
public Physicsmata get(int index){
return peers[index];
}
public void remove(int index){
peers[index] = peers[size-1];
peerMult[index] = peerMult[size-1];
if(index < size-1){
peers[size-1] = null;
peerMult[size-1] = null;
}
size--;
}
/** returns -1 if not found */
public int indexOf(Physicsmata p){
for(int i=0; i<size; i++) if(peers
==p) return i;
return -1;
}
/** How much are we connected? *
This may cost more than its worth. Instead, explore the network deeper and find new peers more often.
protected double peerWeights[];
*/
/** continuously changing peer phase minus my phase *
protected int peerDecayingRelativePhases[];
*/
//TODO recursive fourier as a continuously changing Complex between each 2 peer Physicsmata, or just Angle instead of Complex?
//protected Complex
public Physicsmata(Complex firstPhase){
this.phase = firstPhase;
}
public static final double circleDividedByIntRange = -Math.PI/Integer.MIN_VALUE;
/** seconds is how much to change */
public void nextState(double seconds){
if(seconds > .5) seconds = .5;
double myPhaseDecay = 3.7*seconds;
double peerWeightDecay = myPhaseDecay/(size*3);
/*
double weightedSumRe = 0, weightedSumIm = 0, totalWeights = 0;
for(int i=0; i<size; i++){
Physicsmata peer = peers;
double relativePhase = (peer.phase - phase)*circleDividedByIntRange; //range -pi (inclusive) to pi (exclusive)
double dot = Math.cos(relativePhase); //TODO optimize, create int functions for this kind of thing
//TODO Should dot be taken as absolute value, squared, or as it is?
//double attract = dot;
//double targetWeight = .5+.5*dot;
//peerWeights = peerWeights*(1-decay) + decay*targetWeight;
}*/
Complex sum = new Complex(0, 0);
Complex rotate = new Complex(1,.7).norm();
//Complex rotate = new Complex(1,2).norm();
for(int i=0; i<size; i++){
Physicsmata peer = peers;
//related to fourier in some way, may need 2d matrix of these
//but want to use peers recursively as n-dimensional matrix instead
Complex weight = peerMult;
sum = sum.plus(weight.times(peer.phase));
//My phase is a weighted sum of rotations and scalings of peer phases.
//The Complex peerMult weights should decay toward the best approximation of my phase.
//My phase = targetWeight times this peer phase?
//Complex targetWeight = phase.divide(peer.phase);
//Complex targetWeight = phase.divide(peer.phase).times(new Complex(.6,.
); //spin
Complex targetWeight = phase.divide(peer.phase).times(rotate); //spin
//Still need to find the right radius for targetWeight
//targetWeight is radius 1 because phase and peer.phase are radius 1,
//because every lightcone has 1.0 chance when you're there
double targetRadius = 1./size; //all peers equal radius for now
peerMult = weight.plus(targetWeight.times(peerWeightDecay)).setRadius(targetRadius);
}
//Complex turnALittle = new Complex(1,decay*50).norm();
//Complex t = sum.norm().times(turnALittle);
//Complex t = sum.norm();
//TODO decay toward sum of (fourier transformed?) child phases perpendicular by using new Complex(0,decay)?
//phase = phase.plus(t.times(new Complex(decay,0))).norm();
//phase = phase.plus(t.times(new Complex(0,decay))).norm();
//phase = phase.plus(sum.setRadius(decay));
//phase = phase.plus(sum.setRadius(myPhaseDecay));
phase = phase.plus(sum.setRadius(myPhaseDecay)).norm();
//phase = sum;
}
/** Returns the part of the quantum state at the center of this lightcone.
The other part is which Physicsmatas this Physicsmata is connected to,
at what angles, how much, and this same function on them as a network with cycles.
*/
public Complex phase(){
return phase;
}
/** TODO this doesn't work well with phase being updated as a function of near Physicsmatas,
but this function will have some effect if its called on many Physicsmatas near eachother.
*/
public void setPhase(Complex phase){
this.phase = phase;
}
//child Physicsmatas
//distance of each child Physicsmata from here, as a phase alignment and amplitude?
}
