Keresés

Részletes keresés

pk1 Creative Commons License 2016.04.01 0 0 1133

Amit én nem értek:

a rajzon középen is kéne foltnak lennie.

Lehet, hibás az ábra?

Előzmény: légigjhfghfgfgfhgfkjhlh (1131)
pk1 Creative Commons License 2016.04.01 0 0 1132

Szintén üdvözlet, válaszaim sorban:

Mivel a fluoreszkáló ernyőn nem egy középen levő folt van, hanem valami más, hullámtermészetre lehet következtetni.

A grafitrétegen áthaladva nem változik az elektron hullámhossza.

A gyorsítóból érkező elektronok nem ütnek ki elektronokat, hanem elhajlanak.

A grafit szénatomjain az elektronok minden irányban elhajlanak, ettől lesz gyűrű alakú a kép. 

Ha az ernyőn a kép nem kör alakú lenne, az azt jelentené, hogy más a grafit szerkezete, vagy pedig szennyezett. Éppen ezért jók a diffrakciós kísérletek szerkezetfelderítésre, tisztaságvizsgálatra.

A teljességhez hozzátartozik, hogy nem egy gyűrű van, de itt az ábrán levő gyűrűvel koncentrikus másodlagos, harmadlagos, stb. gyűrűk nagyobb sugarúak, nem fértek rá az ernyőre.

A kísérletbeli elektronsugár hullámhossza kiszámítható, és az jön ki, hogy mintegy ötöde-tizede a szénatom átmérőjének.

 

Itt egy példa arra, amikor a kép nem gyűrű: ezüst atomokkal szennyezett szilícium elektrondiffrakciós képe:

 

Előzmény: légigjhfghfgfgfhgfkjhlh (1131)
légigjhfghfgfgfhgfkjhlh Creative Commons License 2016.03.31 0 0 1131

Üdvözlet és elnézés,ha teljesen nem jó topikban járnék a kérdésemmel!

Egy jelenlegi középiskolai anyag megértésével van problémám,ugyanis valamit vagy úgy elsőre,vagy szinte soha.

 

 

Szóval a fenti kísérlet miként igazolja az elektron hullámtermészetét? Az elektronsugár áthalad a grafitrétegen de megváltozik közben a hullámhossza? Talán elektronokat "üt ki" a grafitból és azok csapódnak az ernyőbe? Ha az ernyőn a kép nem kör alakú lenne -hanem mondjuk ellipszis - ,akkor a kísérlet cáfolta volna az elméletet? Végül is nincs nekem ennyi kérdésem,csak alapjában véve nem értem a lényeget.

aquatikk Creative Commons License 2016.03.09 0 0 1130

A "weak measurement" tipusú kisérletek a legújabb ösvény a kisérleti fizikában. És elég meglepő eredményeket adnak.

http://arxiv.org/abs/1304.7469

A 2B ábrán destruktív interferenciát hoznak létre az F tükrön. Az F tükör fele nem "halad" foton amit a 2C elrendezés jó szemléltet. Ennek ellenére a 2B kisérlet detektorán megjelenik az A és B tükrök frekvenciája.

Az egyetlen lehetséges "mechanizmust" a TSVF adja ahogyan a cikk is rámutat.

 

https://en.wikipedia.org/wiki/Two-state_vector_formalism

Ami egy retrocausality variáns.  Meglepően.

aquatikk Creative Commons License 2016.03.09 0 0 1129

Hogy mennyire térszerű az idő azt legjobban a foton spinje mutatja meg.

 

"The magnitude of its spin is and the component measured along its direction of motion, its helicity, must be ±ħ."

https://en.wikipedia.org/wiki/Photon#Physical_properties

 

Vajon miért? Mert a foton 45 fokban mozog a téridőben és a valós spinje arra áll. Ennek a térszerű komponense 1 ha az eredeti hossz sqrt 2

 

 

aquatikk Creative Commons License 2016.03.09 0 0 1128

A QM nem tudja különállóan leírni a detektorok valószínűségeit.

Erre csak a "retrocausality" tipusú elméletek képesesek.

 

Természetesen ezek ismertek de szinte senki nem fogadja el.

https://en.wikipedia.org/wiki/Interpretations_of_quantum_mechanics#Time-symmetric_theories

 

Ami számomra érthetetlen.

Ugyanis Einstein "térszerűsítette" az idő dimenziót.

Akkor nem igazán értem, miért ne lehetne ebben mindenfele mozogni.

Ez amolyan tudományos skizofenia. Mindenki örül a gravitációs hullámnak, de az időt mint egy újabb térszerű dimenziót senki nem hajlandó elfogadni.

aquatikk Creative Commons License 2016.03.09 0 0 1127

"One idea is to replace instantaneous communication with a process that travels backwards in time along the past light cone. This is the idea behind a transactional interpretation of quantum mechanics, which interprets the statistical emergence of a quantum history as a gradual coming to agreement between histories that go both forward and backward in time."

https://en.wikipedia.org/wiki/Bell's_theorem#Metaphysical_aspects

 

 

"Thus future values of the force affect the acceleration of the particle in the present."

https://en.wikipedia.org/wiki/Abraham%E2%80%93Lorentz_force#Signals_from_the_future

 

 

"Watanabe proposed that information given by forwards evolving quantum states is not complete; rather, both forwards and backwards evolving quantum states are required to describe a quantum state: a first state vector that evolves from the initial conditions towards the future, and a second state vector that evolves backwards in time from future boundary conditions. Past and future measurements, taken together, provide complete information about a quantum system."

https://en.wikipedia.org/wiki/Two-state_vector_formalism

 

 

https://en.wikipedia.org/wiki/Wheeler%E2%80%93Feynman_absorber_theory

 

https://en.wikipedia.org/wiki/Retrocausality

 

aquatikk Creative Commons License 2016.03.09 0 0 1126

A Bell egyenlötlenség és a retrokauzalitás.


#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <X11/Xlib.h>


double iradian=(M_PI/180.0);

Display *dpy;
Window win;
GC gc;


void pixel(int x,int y,int color)
{
    XSetForeground(dpy,gc,color);
    XDrawPoint(dpy, win, gc, x,y);
}
void line(int x1,int y1,int x2,int y2,int color)
{
    XSetForeground(dpy,gc,color);
    XDrawLine(dpy, win, gc, x1,y1,x2,y2);
}
void initX11()
{
    dpy = XOpenDisplay(0);
    win = XCreateSimpleWindow(dpy, DefaultRootWindow(dpy), 0,0, 900, 650, 0,0,0);
    
    XSelectInput(dpy, win, StructureNotifyMask);
    XMapWindow(dpy, win);
    gc = XCreateGC(dpy, win, 0, 0);
    
    for(;;) { XEvent e; XNextEvent(dpy, &e); if (e.type == MapNotify) break; }
}





double cos2(double a)
{
    a=cos(a);
    return a*a;
}
double sin2(double a)
{
    a=sin(a);
    return a*a;
}


double S2classic(double a,double b,double a2,double b2)
{
    double N=0.0,step=M_PI/180.0,
        Pp1=0,Pm1=0,
        Pp2=0,Pm2=0,
        Pp3=0,Pm3=0,
        Pp4=0,Pm4=0;
    
    for(double p=0.0;p<2.0*M_PI;p+=step)
    {
        Pp1+=cos2(p-a)*cos2(p-b)*step;
        Pm1+=sin2(p-a)*cos2(p-b)*step;
    
        Pp2+=cos2(p-a)*cos2(p-b2)*step;
        Pm2+=sin2(p-a)*cos2(p-b2)*step;

        Pp3+=cos2(p-a2)*cos2(p-b)*step;
        Pm3+=sin2(p-a2)*cos2(p-b)*step;

        Pp4+=cos2(p-a2)*cos2(p-b2)*step;
        Pm4+=sin2(p-a2)*cos2(p-b2)*step;
    }
    Pp1/=(2.0*M_PI);    Pm1/=(2.0*M_PI);
    Pp2/=(2.0*M_PI);    Pm2/=(2.0*M_PI);
    Pp3/=(2.0*M_PI);    Pm3/=(2.0*M_PI);
    Pp4/=(2.0*M_PI);    Pm4/=(2.0*M_PI);
    
    N =(Pp1-Pm1)/(Pp1+Pm1);
    N-=(Pp2-Pm2)/(Pp2+Pm2);
    N+=(Pp3-Pm3)/(Pp3+Pm3);
    N+=(Pp4-Pm4)/(Pp4+Pm4);
    
    return N;
}
double S2retrocausal(double a,double b,double a2,double b2)
{
    double N=0.0,step=M_PI/180.0,
        Pp1=0,Pm1=0,
        Pp2=0,Pm2=0,
        Pp3=0,Pm3=0,
        Pp4=0,Pm4=0;
    
    for(double p=0.0;p<2.0*M_PI;p+=step)
    {
        for(int i=0;i<4;i++)
        {
            double w;

            if(i==0) w=a;
            if(i==1) w=b;
            if(i==2) w=a+M_PI/2;
            if(i==3) w=b+M_PI/2;
            Pp1+=cos2(w-a)*cos2(w-b)*step/4.0;
            Pm1+=sin2(w-a)*cos2(w-b)*step/4.0;
        
            if(i==0) w=a;
            if(i==1) w=b2;
            if(i==2) w=a+M_PI/2;
            if(i==3) w=b2+M_PI/2;
            Pp2+=cos2(w-a)*cos2(w-b2)*step/4.0;
            Pm2+=sin2(w-a)*cos2(w-b2)*step/4.0;
    
            if(i==0) w=a2;
            if(i==1) w=b;
            if(i==2) w=a2+M_PI/2;
            if(i==3) w=b+M_PI/2;
            Pp3+=cos2(w-a2)*cos2(w-b)*step/4.0;
            Pm3+=sin2(w-a2)*cos2(w-b)*step/4.0;
    
            if(i==0) w=a2;
            if(i==1) w=b2;
            if(i==2) w=a2+M_PI/2;
            if(i==3) w=b2+M_PI/2;
            Pp4+=cos2(w-a2)*cos2(w-b2)*step/4.0;
            Pm4+=sin2(w-a2)*cos2(w-b2)*step/4.0;
        }
    }
    Pp1/=(2.0*M_PI);    Pm1/=(2.0*M_PI);
    Pp2/=(2.0*M_PI);    Pm2/=(2.0*M_PI);
    Pp3/=(2.0*M_PI);    Pm3/=(2.0*M_PI);
    Pp4/=(2.0*M_PI);    Pm4/=(2.0*M_PI);
    
    N =(Pp1-Pm1)/(Pp1+Pm1);
    N-=(Pp2-Pm2)/(Pp2+Pm2);// - because a-b2 is the biggest difference
    N+=(Pp3-Pm3)/(Pp3+Pm3);
    N+=(Pp4-Pm4)/(Pp4+Pm4);
    
    return N;
}

double S2qm(double a,double b,double a2,double b2)
{
    double N=0.0,Pp=0,Pm=0;
    
    Pp=0.5*cos2(a-b);
    Pm=0.5*sin2(a-b);
    N=(Pp-Pm)/(Pp+Pm);

    Pp=0.5*cos2(a-b2);
    Pm=0.5*sin2(a-b2);
    N-=(Pp-Pm)/(Pp+Pm);

    Pp=0.5*cos2(a2-b);
    Pm=0.5*sin2(a2-b);
    N+=(Pp-Pm)/(Pp+Pm);

    Pp=0.5*cos2(a2-b2);
    Pm=0.5*sin2(a2-b2);
    N+=(Pp-Pm)/(Pp+Pm);

    return N;
}



int bell()
{
    initX11();
    
    line(0,100,180*4,100,0x555555);
    line(0,150,180*4,150,0x555555);
    line(0,200,180*4,200,0x999999);
    line(0,250,180*4,250,0x555555);
    line(0,300,180*4,300,0x555555);

    line(22*4,0,22*4,300,0x555555);//22.5 critical angle
    
    for(int angle=0;angle<180;angle+=2)
    {
        double S=0.0,a,a2,b,b2;
       
        a=0.0*iradian;
        b=angle*iradian;
        a2=angle*2.0*iradian;
        b2=angle*3.0*iradian;
       

        printf("%d:  ",angle);
    
        S=S2classic(a,b,a2,b2 );        printf("classic: %f ",S);         pixel(angle*4,200-S*50.0,0x0000ff);//blue
        S=S2retrocausal(a,b,a2,b2 );       printf("retrocausal: %f  ",S);     pixel(angle*4,200-S*50.0,0x00ff00);//green
        S=S2qm(a,b,a2,b2 );                printf("qm: %f n",S);             pixel(angle*4+1,200-S*50.0,0xff0000);//red   
        XFlush(dpy);
    }

    XFlush(dpy);
    getchar();
}

int main()
{
    bell();
}

aquatikk Creative Commons License 2016.03.09 0 0 1125

Asking photons where have they been
http://arxiv.org/abs/1304.7469
In conclusion, we have performed direct measurements which shed new light on the question: Where were the
photons passing through an interferometer? The main results are presented in Fig. 2B. The photons themselves
tell us where they have been. And the story they tell is surprising. The photons do not always follow continuous
trajectories. Some of them have been inside the nested interferometer (otherwise they could not have known the
frequencies fA , fB ), but they never entered and never left the nested interferometer, since otherwise they could not
avoid the imprints of frequencies fE and fF of mirrors E and F leading photons into and out of the interferometer.
Only the description with both forward and backward evolving quantum states provides a simple and intuitive picture
of pre- and postselected quantum particles.

 

 

Can a Future Choice Affect a Past Measurement's Outcome?
http://arxiv.org/abs/1206.6224
"8. Ergo, the weak measurements’ agreement with the strong
measurements could have been obtained only by the former
anticipating the spin orientation to be chosen for the latter. This result
indicates the existence of a hidden variable of a very subtle type,
namely the future state-vector."

 

dedpul Creative Commons License 2016.01.24 0 0 1124
Előzmény: as3yo (1047)
taruss Creative Commons License 2015.11.29 0 0 1123

"Az amplitudó automatikusan négyzetre emelődött, magyarázatot adva arra, miért így kell számolni a hullámfüggvénnyel az amplitudót."

 

"Having interpreted the conjugate state vector as an advanced wave, it is claimed that the origins of the Born rule follow naturally from the description of a transaction.[1]"

https://en.wikipedia.org/wiki/Transactional_interpretation

 

Előzmény: r3ggeli (753)
numbernine Creative Commons License 2015.06.07 0 0 1122

"Sajnos a két eset megkülönböztethetetlen, ahogy az már a stackexchange-en olvashattuk."

 

Ez így nem teljesen igaz. A kisérlet megkülönbözteti a két esetet.

Ameddig nincs más magyarázat, addig ez az egyetlen.

 

Persze lehet hinni abban is, hogy egy varázslat miatt korrelál a két foton, amit tilos leírni, mert akkor baj érhet minket.

Csakhogy nem mindenki fél a démonoktól.

Előzmény: numbernine (1118)
numbernine Creative Commons License 2015.06.07 0 0 1121

Physics team entangles photons that never coexisted in time

 

http://phys.org/news/2013-05-physics-team-entangles-photons-coexisted.html

 

numbernine Creative Commons License 2015.06.07 0 0 1120

A program csak az entangled fotonokkal számol. Felmerül az emberben a kérdés, hogy a lézer összer fotonja ilyen? Egyáltalán nem.

"The conversion efficiency is very low, on the order of 1 pair per every 10^12 incoming photons"

http://en.wikipedia.org/wiki/Spontaneous_parametric_down-conversion

 

 

Akkor mégis hogy van ez?

A program csak a csatolt fotonokkal számol. Ebben semmi rendkívüli nincs, egy kisérleti fizikus a kisérletnél ugyan ezt teszi.

Jön a két fénysugár a BBO kristályról. Az egyedi fotondetektálás senkit nem érdekel.

Feltesszük a két detektort polarizátorok nélkül. Ekkor kapunk X db KÖZÖS detektálást. Úgy vesszük, hogy ennyi entangled fotonunk van. (a detektor hatásfoka sem 100% de ezt is bele lehet(kell) számolni.)

Most feltesszük a polarizátorokat, és az újabb KÖZÖS detektálási értéket viszonyítjuk a polarizátor nélkül kapott értékhez,

 

Sokaknak speciális (pl 3 fotonos) összefonódás kell ahhoz, hogy elhiggye, nem a detektor hatásfoka itt a probléma. Nos az egyenlet annyira specifikus (1/2sin2(a) vagy 1/2cos2(a) ) , hogy a detektor hatásfoka nem ronthaná el az eredményt ilyen irányban.

 

A végtelen sebességű kapcsolat nevetséges, ha arra gondolok, hogy olyan fotonokat is összecsatoltak, amelyek nem is léteztek egy időben.

numbernine Creative Commons License 2015.06.07 0 0 1119

Ja és az egyedi polarizátorok valószínűségeit is láthatjuk. Nem változik semmi az egyedi detektoroknál, nem lehet üzeneteket küldeni ezzel a módszerrel az egyik oldalról a másikra. Csak akkor, ha mindkét detektálás eredményét ismerjük. /coincidence/

Ezt használja ki a kvantum titkosítás.

numbernine Creative Commons License 2015.06.07 0 0 1118

state_backwardfull

Nos ez az eset nem helyes ilyen formában. Sikeresen bebizonyosodott az amit eddig is tudott mindenki.

A foton nem a detektortól indul. LOL

 

state_backwardlightsourcemodified

Ellenben ez tökéletes egyezést ad a QM-el. A forrás polarizáció irányát módosítják a polarizátorok. A forrás polarizációs iránya mindig valamelyik polarizátor tengelyével párhuzamos, vagy arra merőleges. Igy úgy tűnik, mintha a fénynyaláb polarizálatlan lenne. Sajnos a két eset megkülönböztethetetlen, ahogy az már a stackexchange-en olvashattuk.

numbernine Creative Commons License 2015.06.07 0 0 1117

Hogyan néz ki a linken levő integrálás?

 

enum
{
state_classic,
state_backwardfull,
state_backwardlightsourcemodified
};

//int state=state_classic;
//int state=state_backwardfull;
int state=state_backwardlightsourcemodified;

int ortho=0;
//int ortho=1;


#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <X11/Xlib.h>


Display *dpy;
Window win;
GC gc;
double iradian=(M_PI/180.0);


void pixel(int x,int y,int color)
{
    XSetForeground(dpy,gc,color);
    XDrawPoint(dpy, win, gc, x,y);
}
void line(int x1,int y1,int x2,int y2,int color)
{
    XSetForeground(dpy,gc,color);
    XDrawLine(dpy, win, gc, x1,y1,x2,y2);
}
void initX11()
{
    dpy = XOpenDisplay(0);
    win = XCreateSimpleWindow(dpy, DefaultRootWindow(dpy), 0,0, 800, 550, 0,0,0);
    
    XSelectInput(dpy, win, StructureNotifyMask);
    XMapWindow(dpy, win);
    gc = XCreateGC(dpy, win, 0, 0);
    
    for(;;) { XEvent e; XNextEvent(dpy, &e); if (e.type == MapNotify) break; }
}
double sqr(double n) // x^2
{
    return n*n;
}
double doublerand() //rand  0.0-1.0
{
    return (double)(rand()%10000)/10000.0;
}
struct vec2d
{
    double x,y;
    
    vec2d() {x=0;y=0;}
    vec2d operator *(double c)
    {
        vec2d u;
        u.x=x*c;
        u.y=y*c;
        return u;
    }
};
double dot(vec2d *v1,vec2d *v2)
{
    return v1->x*v2->x + v1->y*v2->y;
}
void add_amp(vec2d *v,double phase,double ax)
{
    v->x += sin(phase)*ax;
    v->y += cos(phase)*ax;
};
void add_polarizer2(vec2d *v,double phase)
{
    vec2d pol;

    add_amp(&pol,phase,1.0);
    double amp=dot(v,&pol);      //v'=pol><pol|v>
    v->x = pol.x*amp;    
    v->y = pol.y*amp;
};
double probability(vec2d v1)
{
    return dot(&v1,&v1);
}

int main()
{
    initX11();


    for(int i=100;i<500;i+=20)      line(0,i,400,i,0x005500);
        line(0,500,400,500,0x00aa00);
        line(0,300,400,300,0x00aa00);
        line(0,100,400,100,0x00aa00);



    for(int x=0;x<360;x++)
    {
        double P=0,P1=0,P2=0,step=1e-2;
        double polarizator1=(double)x*iradian;
        double polarizator2=0;//(22.5*iradian);

        for(double i=0;i<=2.0*M_PI;i+=step)
        {
              vec2d amp2,amp1;
            double photon1_polarization=i;
            double photon2_polarization=i;
            if(ortho==1) photon2_polarization=i+M_PI/2;

     
#if 0
//check
#if 1
            P+=sqr(cos(photon1_polarization - polarizator1))*
                    sqr(cos(photon2_polarization - polarizator2))*step;
#else                    
            P+=sqr(cos(photon1_polarization - polarizator1))*
                    sqr(cos(polarizator1-polarizator2))*step;
#endif
#else //#################################################################################           
//integral
            int direction=rand()%2;// random 0 or 1
            int randomquarter=rand()%4;// random 0,1,2, or 3

            if(state==state_classic)
            {
                 add_amp(&amp1,photon1_polarization,1.0);
                add_polarizer2(&amp1,polarizator1);

                 add_amp(&amp2,photon2_polarization,1.0);
                add_polarizer2(&amp2,polarizator2);
            }

            if(state==state_backwardfull)
            {
                if(direction==1)
                {
                     add_amp(&amp1,photon1_polarization,1.0);
                    add_polarizer2(&amp1,polarizator1);
    
                     add_amp(&amp2,photon2_polarization,1.0);
                    add_polarizer2(&amp2,polarizator1);
                    add_polarizer2(&amp2,polarizator2);
                }
                else
                {
                     add_amp(&amp1,photon1_polarization,1.0);
                    add_polarizer2(&amp1,polarizator2);
                    add_polarizer2(&amp1,polarizator1);

                     add_amp(&amp2,photon2_polarization,1.0);
                    add_polarizer2(&amp2,polarizator2);
                }
            }

            if(state==state_backwardlightsourcemodified)
            {
                if(direction==1)    photon1_polarization=polarizator2 + M_PI/2*randomquarter;
                else                photon1_polarization=polarizator1 + M_PI/2*randomquarter;

                if(ortho==1) photon2_polarization=photon1_polarization+M_PI/2;
                else         photon2_polarization=photon1_polarization;

                add_amp(&amp1,photon1_polarization,1.0);
                add_polarizer2(&amp1,polarizator1);
                
                 add_amp(&amp2,photon2_polarization,1.0);
                add_polarizer2(&amp2,polarizator2);
            }

            P+=probability(amp1)*probability(amp2)*step;
            P1+=probability(amp1)*step;
            P2+=probability(amp2)*step;

#endif
        }
        P/=(2.0*M_PI);
        P1/=(2.0*M_PI);
        P2/=(2.0*M_PI);
        pixel(x,503-P1*200.0,0x008888);//lightblue  
        pixel(x,502-P2*200.0,0x000088);//blue
        pixel(x,500-P*200.0,0xffff00);//yellow integral /coincidence/

        if(ortho==1) P=0.5*sqr(sin(polarizator2 - polarizator1));
        else         P=0.5*sqr(cos(polarizator2 - polarizator1));
        pixel(x,501-P*200.0,0xff0000);//red QM

    }
    XFlush(dpy);
    getchar();
        
    return 0;
}

Előzmény: numbernine (1116)
numbernine Creative Commons License 2015.06.07 0 0 1116

A program most nem a Monte-Carlo módszerrel megy, mint a régebbiek, hanem integrálással, amit a matematikai formában

a (6) válaszban találhatunk meg.

 

http://physics.stackexchange.com/questions/113564/intensity-of-unpolarized-light-through-polarizer

 

numbernine Creative Commons License 2015.06.07 0 0 1115

Hogyan számol a QM?

Nézzük azt az esetet, amit a program számol. A program figyelembe veszi a QWP működési mechanizmusát, a QM nem.

 

http://arxiv.org/pdf/quant-ph/0106078v1.pdf

 

 

Az L és az R azt jelöli, hogy a QWP jelenléte esetén a foton lehet  balra vagy jobbra cirkulárisan polarizált állapotban.

Hogy hogyan került oda, az a kvantum-mechanikát nem érdekli.

Engem viszont igen.

 

numbernine Creative Commons License 2015.06.07 0 0 1114

"Law 4 is analogous to the multiplication law of probability for independent events; note that it fails for entangled states."

 

http://en.wikipedia.org/wiki/Probability_amplitude

 

Nos mint a számításom mutatja, ez csak klasszikus esetben igaz, Retro kauzitásnál már az entangled state-re is érvényes a negyedik sor.

numbernine Creative Commons License 2015.06.07 0 0 1113

Feynman írta: "There is no field at all"

Sok laikusban az ilyen idézetek keltenek zavart. Mert ahogy észrevettem Magyarországon a QFT azaz a quantum field theory a népszerűbb az oktatók között. Ott a quantum mező az elsődleges.

Ellenben ha megnézzük Feynman QED előadásait a youtube-on, akkor ő a részecskét helyezi előtérbe.

 

Amit a érdeklődő laikus nem tud, hogy ez két eltérő elmélet.

De a két elmélet ugyan azt az eredményt adja,

Ekvivalensek. Számomra ez a szó azt jelenti, hogy ugyan az a kettő, de nem írok ilyen, mert sokak szerint ez mást jelent.

 

Ha egy részecske képes mindenhol ott lenni, akkor az egy mező. A másik, hogy ha egy mező képes rezgésre, az sok részecskéből kell hogy álljon. Ha a mezőben egyetlen részecske (energia adag) van, akkor ott a kvantum harmonikus oszcillátorok (a mező elemei) valahogyan egy egészet alkotnak.

 

Persze köztudott, hogy a részecskét csak egyetlen helyen lehet detektálni, tehát azt mondani, hogy minden irányba halad, helytelen.

A legtöbb ember szerint QFT mező csak egy matematikai segédeszköz. Nos lehet.

 

De akkor már csak egyetlen magyarázat marad.

Akkor világunk egy szimuláció.

numbernine Creative Commons License 2015.06.06 0 0 1112
numbernine Creative Commons License 2015.06.06 0 0 1111
numbernine Creative Commons License 2015.06.06 0 0 1110

"Within a naïve classical word view, quantum mechanics can even mimic an influence of future actions on past events", says Anton Zeilinger.

Read more at: http://phys.org/news/2012-04-quantum-physics-mimics-spooky-action.html#jCp

http://phys.org/news/2012-04-quantum-physics-mimics-spooky-action.html

 

 

"There is no field at all"

http://www.nobelprize.org/nobel_prizes/physics/laureates/1965/feynman-lecture.html

"the advanced effects really cancel in every case "

...ez az amiért nem sérül az ok-okozat

és nincs időgép. Annak ellenére, hogy ez valamilyen formában igaz.

Ha nem is egy-az egyben a Feynman-Wheeler elmélettel,

 

numbernine Creative Commons License 2015.06.06 0 0 1109

NEWS

 

"(Phys.org)—As an elementary particle, the electron cannot be broken down into smaller particles, at least as far as is currently known. However, in a phenomenon called electron fractionalization, in certain materials an electron can be broken down into smaller "charge pulses," each of which carries a fraction of the electron's charge. Although electron fractionalization has many interesting implications, its origins are not well understood.

Read more at: http://phys.org/news/2015-05-electron.html#jCp"

http://phys.org/news/2015-05-electron.html

 

 

“The thing you call the ‘quark’ might have quark-antiquark pairs and glue and all the rest built into it,”

http://www.wired.com/2014/09/tetraquark-quantum-feud/

 

"Here, the probability of finding a particle in a particular place is the product of two vectors: one evolving forwards in time from the source and one evolving backwards in time from the detector."

http://physicsworld.com/cws/article/news/2013/nov/26/physicists-ask-photons-where-have-you-been

 

http://en.wikipedia.org/wiki/Two-state_vector_formalism

 

 

numbernine Creative Commons License 2015.06.06 0 0 1108

Félreérthető amit írtam Szóval a két megoldásnak semmi köze a komplex számokhoz, hanem az egyik klasszikus a másik retrokauzális. Az elsőnek kicsi az amplitudója, emiatt az igazi megoldás az utolsó. Mint már írtam, ez mindig helyes választ ad attól függetlenül, hogy hány embernek nem tetszik. (nekem se)

 

1) prgst_ERASERpresentClassic,
2.) prgst_backwardcausality

 

numbernine Creative Commons License 2015.06.06 0 0 1107

Figyelem! Ez nem Quantum mechanikai szimuláció (integrálás).

Az sokkal egyszerűbb, mivel csak leírja a folyamatot, nem magyarázza.

 

Ez egy lehetséges magyarázat a jelenségre. Ahogy Zeilinger mondta, a kvantumfizikát utánozhatjuk, ha megengedjük hogy a jövő hatással legyen a múltra. Az emberek ezt soha nem fogják elfogadni, de az legyen az ő bajuk.

numbernine Creative Commons License 2015.06.06 0 0 1106

complex operator *(complex c)
    {
        complex e;
        e.real = this->real*c.real - this->img*c.img;
        e.img = this->img*c.real + this->real*c.img;
        return e;
    }

 

Na és miért kell konjugáltat venni? Mert a DOT() product-hoz nekünk a real résznél összeadásra van szükségünk.

dot(a,b) = a.real*b.real - a.img*(-b.img)

 

numbernine Creative Commons License 2015.06.06 0 0 1105

void add_polarizer2(complex *v,double phase)
{
    complex pol,cpol;

    add_amp(&pol,phase,1.0);

    cpol=pol;

    cpol.conjugate(); //<pol
    complex amp=(*v)*cpol; amp.img=0;      //v'=pol><pol|v>
    *v = pol*amp;    
};

 

De igazából nem lényeg. A komplex számítás csak egy matematikai trükk amivel sok mindent le lehet egyszerűsíteni.

numbernine Creative Commons License 2015.06.06 0 0 1104

void add_polarizer(vec2d *v,double phase)
{
    v->x *= sin(phase);
    v->y *= cos(phase);
};

 

Az itt a probléma, hogy ez az egyenlet némelyik esetben nem jó eredményt ad.

A probléma megoldható a QM-ből kölcsönvett vetítő projekciós operátorral (projektor).

 

"Általában a |ψihψ| operátor úgy hat a tőle jobbra álló ket vektorra, hogy először skalárszorozza hψ|-vel, ezáltal leolvassa a
|ψi egységvektorra való vetület hosszát, majd ezzel a számmal megszorozva ugyanezt az egységvektort, el ̋oállítja a vetületet."

Geszti Tamás Kvantummechanika  77.oldal

 

void add_polarizer2(vec2d *v,double phase)
{
    vec2d pol;

    add_amp(&pol,phase,1.0);
    double amp=dot(v,&pol);      //v'=pol><pol|v>
    v->x = pol.x*amp;    
    v->y = pol.y*amp;
};

 

Azok kedvéért, akik nem hiszik el, hogy a forgó vektor és a komplex szám gyakorlatilag ugyan azt az eredményt adja, itt a lesz a komplex megoldás is.

Igy már két megoldás van, bár a klasszikus megoldásnál túl kicsi  az amplitudó.

 

 


//#define _COMPLEXNUMBER

enum{
prgst_noQWP,
prgst_QWPpresent,
prgst_ERASERpresent,
prgst_ERASERpresentClassic,
prgst_backwardcausality
};
//    int prgstate=prgst_noQWP;
//    int prgstate=prgst_QWPpresent;
//    int prgstate=prgst_ERASERpresent;
//    int prgstate=prgst_ERASERpresentClassic;
    int prgstate=prgst_backwardcausality;


#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <X11/Xlib.h>


Display *dpy;
Window win;
GC gc;
double iradian=(M_PI/180.0);


void pixel(int x,int y,int color)
{
    XSetForeground(dpy,gc,color);
    XDrawPoint(dpy, win, gc, x,y);
}
void line(int x1,int y1,int x2,int y2,int color)
{
    XSetForeground(dpy,gc,color);
    XDrawLine(dpy, win, gc, x1,y1,x2,y2);
}
void initX11()
{
    dpy = XOpenDisplay(0);
    win = XCreateSimpleWindow(dpy, DefaultRootWindow(dpy), 0,0, 800, 550, 0,0,0);
    
    XSelectInput(dpy, win, StructureNotifyMask);
    XMapWindow(dpy, win);
    gc = XCreateGC(dpy, win, 0, 0);
    
    for(;;) { XEvent e; XNextEvent(dpy, &e); if (e.type == MapNotify) break; }
}
double sqr(double n) // x^2
{
    return n*n;
}
double doublerand() //rand  0.0-1.0
{
    return (double)(rand()%10000)/10000.0;
}



#ifdef _COMPLEXNUMBER
#define vec2d complex

struct complex
{
    double real,img;

    complex() {real=img=0;};
    complex(double r,double i) {real=r;img=i;};
    void set(double r,double i) {real=r;img=i;};
    void set(complex c) {real=c.real;img=c.img;};

    void conjugate() {img*=-1.0;}
    complex operator +(complex c)
    {
        complex e;
        e.real = this->real + c.real;
        e.img = this->img + c.img;
        return e;
    }
    complex operator -(complex c)
    {
        complex e;
        e.real = this->real - c.real;
        e.img = this->img - c.img;
        return e;
    }
    complex operator *(complex c)
    {
        complex e;
        e.real = this->real*c.real - this->img*c.img;
        e.img = this->img*c.real + this->real*c.img;
        return e;
    }
    complex operator /(complex c)
    {
        complex e;
        double denominator=c.real*c.real + c.img*c.img;
        e.real = (this->real * c.real + this->img * c.img)/denominator;
        e.img = (this->img * c.real - this->real * c.img)/denominator;
        return e;
    }
    complex operator *(double c)
    {
        complex e;
        e.real = this->real*c;
        e.img = this->img*c;
        return e;
    }
};
void add_amp(complex *v,double phase,double ax)
{
    *v = *v + complex(sin(phase)*ax,cos(phase)*ax);
};
void add_polarizer2(complex *v,double phase)
{
    complex pol;

    add_amp(&pol,phase,1.0);
    complex amp=(*v)*pol; amp.img=0;      //v'=pol><pol|v>
    *v = pol*amp;    
};
double probability(complex c1,complex c2)
{
    c1.conjugate();// <c1|
    complex P=c1*c2; //<c1|c2>

    return P.real;
}
void add_quarterwaveplatel2c(vec2d *v,double phase,double dist,double qwp_angle,double ax)
{
    complex axis_fast,axis_slow,input_wave;
    
    add_amp(&axis_fast,qwp_angle,1.0);
    add_amp(&axis_slow,qwp_angle+90.0*iradian,1.0);
    add_amp(&input_wave,phase,1.0);

    complex amp_fast=axis_fast*input_wave; amp_fast.img=0;
    complex amp_slow=axis_slow*input_wave; amp_slow.img=0;
    
    amp_fast=amp_fast*complex(cos(dist)*ax,0.0);
    amp_slow=amp_slow*complex(sin(dist)*ax,0.0);//-+90 phase shift
    
    *v=*v+axis_fast*amp_fast + axis_slow*amp_slow;
};

#else //###########################################################################################
struct vec2d
{
    double x,y;
    
    vec2d() {x=0;y=0;}
    vec2d operator *(double c)
    {
        vec2d u;
        u.x=x*c;
        u.y=y*c;
        return u;
    }
};
double dot(vec2d *v1,vec2d *v2)
{
    return v1->x*v2->x + v1->y*v2->y;
}
void add_amp(vec2d *v,double phase,double ax)
{
    v->x += sin(phase)*ax;
    v->y += cos(phase)*ax;
};
void add_polarizer2(vec2d *v,double phase)
{
    vec2d pol;

    add_amp(&pol,phase,1.0);
    double amp=dot(v,&pol);      //v'=pol><pol|v>
    v->x = pol.x*amp;    
    v->y = pol.y*amp;
};
double probability(vec2d v1,vec2d v2)
{
    return dot(&v1,&v2);
}


//linear to circular
void add_quarterwaveplatel2c(vec2d *v,double phase,double dist,double qwp_angle,double ax)
{
    vec2d axis_fast,axis_slow,input_wave;
    
    add_amp(&axis_fast,qwp_angle,1.0);
    add_amp(&axis_slow,qwp_angle+90.0*iradian,1.0);
    add_amp(&input_wave,phase,1.0);

    double amp_fast=dot(&axis_fast,&input_wave);
    double amp_slow=dot(&axis_slow,&input_wave);
    
    amp_fast=cos(dist)*amp_fast;
    amp_slow=sin(dist)*amp_slow;//-+90 phase shift
    
    v->x += (axis_fast.x*amp_fast + axis_slow.x*amp_slow)*ax;
    v->y += (axis_fast.y*amp_fast + axis_slow.y*amp_slow)*ax;
}
#endif //###########################################################################################

int main()
{
    initX11();


    for(int i=100;i<500;i+=20)      line(0,i,400,i,0x005500);
        line(0,500,400,500,0x00aa00);
        line(0,300,400,300,0x00aa00);
        line(0,100,400,100,0x00aa00);

    
    double eraser_angle=(-45.0*1.0)*iradian;//+-45

    for(int ds_x=0;ds_x<200;ds_x++)//Ds position  -+4mm    
    {
        double P=0,Pds=0,Pdp=0;
        
        double step=0.01;
        for(double p=0;p<M_PI*2.0;p+=step)
        {
            vec2d amp_dp,amp_ds;
            double photon_pol_a, photon_pol_b;

//            if prgstate!=prgst_ERASERpresentClassic AND prgstate!=prgst_backwardcausality
            photon_pol_a=0;// QM for BBO
               photon_pol_b=0+M_PI/2;
            if(rand()%100<50)    {    photon_pol_a=M_PI/2;photon_pol_b=0;    }

            if(prgstate==prgst_ERASERpresentClassic)
            {
                photon_pol_a=p;//classic
                photon_pol_b=p+M_PI/2;
            }
            if(prgstate==prgst_backwardcausality)
            {
                photon_pol_a=eraser_angle;//source modified by Dp polarizer (eraser)
                photon_pol_b=eraser_angle+M_PI/2;
                if(rand()%100<50)    {    photon_pol_a=eraser_angle+M_PI/2;photon_pol_b=eraser_angle;    }
            }
     

            double dphase1=M_PI*2*doublerand();

            double ds_distance=1250.0-420.0;//mm  125-42 cm
            double dp_distance=980.0; //98 cm
            double wavelength=702.2e-6;//mm      e-9m
            double k=2.0*M_PI/wavelength;//wave number
            double hole_dist=0.2;//0.2
            double hole_wide=0.2;//0.2mm  = 200 micrometer wide   
            double ds_pos=4.0*(double)(ds_x-100)/100.0;//+-4mm     Ds position
            int slit_wide=10;
            
            for(int w=0;w<slit_wide;w++)
            {
                double hole1x=hole_dist/2.0 + hole_wide*(double)w/slit_wide;//hole A
                double hole2x=-hole_dist/2.0 - hole_wide*(double)w/slit_wide;//hole B
                double dist1=sqrt(sqr(ds_pos - hole1x) + sqr(ds_distance));
                double dist2=sqrt(sqr(ds_pos - hole2x) + sqr(ds_distance));    

                if(prgstate==prgst_noQWP)
                {
                    add_amp(&amp_dp,photon_pol_a ,1.0);
                    add_amp(&amp_ds,photon_pol_b +dist1*k +dphase1,0.5);
                    add_amp(&amp_ds,photon_pol_b +dist2*k +dphase1,0.5);
                }
                else
                //if(prgstate==prgst_QWPpresent || prgstate==prgst_ERASERpresent ||prgstate==prgst_backwardcausality || prgst_ERASERpresentClassic)
                {
                    add_amp(&amp_dp,photon_pol_a ,1.0);
                       add_quarterwaveplatel2c(&amp_ds,photon_pol_b, dist1*k +dphase1,-45.0*iradian,0.5);
                    add_quarterwaveplatel2c(&amp_ds,photon_pol_b, dist2*k +dphase1, 45.0*iradian,0.5);
                }   
            }
            double normalization_factor=1.0/(double)slit_wide;
            amp_ds=amp_ds*normalization_factor;
            amp_dp=amp_dp*normalization_factor;
            
            if(prgstate==prgst_ERASERpresent || prgstate==prgst_backwardcausality ||prgst_ERASERpresentClassic)
                    add_polarizer2(&amp_dp,eraser_angle);// polarizer(eraser) before Dp  

            P+=probability(amp_dp,amp_dp)*probability(amp_ds,amp_ds)*step;
            Pds+=probability(amp_ds,amp_ds)*step;
            Pdp+=probability(amp_dp,amp_dp)*step;
        }
        P/=(M_PI*2.0);       pixel(ds_x*2,501-P*400.0,0xffff00);//520
        Pds/=(M_PI*2.0);     pixel(ds_x*2,500-Pds*400.0,0xff0000);
        Pdp/=(M_PI*2.0);     pixel(ds_x*2,502-Pdp*400.0,0x00ff);
    }


    XFlush(dpy);
    getchar();
        
    return 0;
}

Ha kedveled azért, ha nem azért nyomj egy lájkot a Fórumért!