Keresés

Részletes keresés

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;
}

guardy Creative Commons License 2015.02.22 0 0 1103
guardy Creative Commons License 2015.02.21 0 0 1102

Ez egy időgép. Miért nem fog működni?

A választ mindenki tudja. Ha az elektron és a pozitron találkozik, megsemmisül.

Ez védi meg a világunkat a paradoxonoktól.

 

Előzmény: as3yo (1085)
guardy Creative Commons License 2015.02.21 0 0 1101

upsz a második idézet elveszett

 

"Van azonban még egy csavar a történetben, ami fél évszázaddal ezelőtt még az elmélet fatális hibájának tűnt. Az egész ügy csak akkor működik, ha az elektron által kisugárzott energia az utolsó szemig időben „visszaverődik”. Ha a sugárzás egy része kiszökik az üres térbe, és soha többé nem találkozik töltött részecskével, akkor az egyenletek nem fognak egyensúlyba kerülni. Régebben azt gondolták, hogy a Világegyetem térbeli kiterjedését tekintve végtelen, és „nyílt” szerkezetű. Ha minden sugárzást vissza akarunk terelni az eredetéhez, az éppoly reménytelen, mintha egy fedél nélküli dobozban akarnánk benntartani a sugárzást. A Wheeler-Feynman-elmélet csak akkor ad helyes választ, ha a Világegyetem zárt dobozra hasonlít (vagyis olyan, mint egy fekete lyuk belseje), amelyből egyáltalán nem tud az energia kiszökni."

guardy Creative Commons License 2015.02.21 0 0 1100

schrodinger_kiscicai.pdf

 

"A Wheeler-Feynmanelmélet továbbra is a legjobb magyarázat arra, miért lép fel a sugárzási ellenállás, és hogyan cserélnek fotont a töltött részecskék, bár erre soha nem jönnénk rá abból, ahogyan a legtöbb középiskolában és egyetemen a fizikát tanítják."

 

"A Wheeler-Feynmanelmélet továbbra is a legjobb magyarázat arra, miért lép fel a sugárzási ellenállás, és hogyan cserélnek fotont a töltött részecskék, bár erre soha nem jönnénk rá abból, ahogyan a legtöbb középiskolában és egyetemen a fizikát tanítják."

 

 

guardy Creative Commons License 2015.02.21 0 0 1099

És még ő mondja meg nekem a tutit. Hagyjuk.

If you need to effect change in their own field taken into account, it is very difficult.

guardy Creative Commons License 2015.02.21 0 0 1098

here is, however, an analogue of the formula which is both fully quantum and relativistic, called the "Abraham–Lorentz–Dirac–Langevin equation"

 

http://en.wikipedia.org/wiki/Abraham%E2%80%93Lorentz_force

guardy Creative Commons License 2015.02.21 0 0 1097

http://forum.index.hu/Article/showArticle?t=9221347

 

"Moniz and Sharp [12] have shown that non-relativistic QED for extended objects can be causal and runaway free. Low has shown that runaways apparently don’t occur in spin 1/2 QED [13]. Others [14] have shown how the lowest order-perturbation expansion of the ALD equation can be inferred within conventional relativistic-QED field theory."

 

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

 

guardy Creative Commons License 2015.02.21 0 0 1096

"The great outstanding, unsolved problem of classical electrodynamics, which had been left hanging at the turn of the century, was in fact solved by Feynman and Wheeler by their allowing for electromagnetic effects to propagate backward as well as forward in time."

 

"The Feynman amplitude, by contrast, does not specify a unique history for a wave or particle. In fact, it has no waves or fields of any kind. It simply considers all the paths of a particle between two points and computes the likelihood of each. "

 

 

http://www.colorado.edu/philosophy/vstenger/Timeless/07-qed.pdf

 

 

 

guardy Creative Commons License 2015.02.21 0 0 1095

"

Since light itself of course moves at the speed of light, time doesn't exist for light. From the point of view of a photon, any consideration of time was irrelevant, and so any consideration of the direction of time was irrelevant as well.

Feynman was now able to describe the radiation resistance of an electron as due to interactions with other charged particles, no matter how distant, by assuming an electron emitted photons both forward and backward in time. The photons moving forward in time are known as "retarded waves", since there is a delay between the emission and reception, while the photons moving backward in time are similarly known as "advanced waves".

"

 

http://www.vectorsite.net/tpqm_13.html

 

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