Keresés

Részletes keresés

protag0ras Creative Commons License 2015.01.05 0 0 1004

Érdekes amit írsz. Úgy tudtam, hogy Einstein épp azért nem (vagy azért sem) szerette a kvantumfizikát, mert valamelyest ellentmondani látszott a fénysebesség határsebességének mivoltával.

 

Tudsz adni bővebb információt, hogy mire alapozod amit írtál?

Előzmény: jogértelmező (1003)
jogértelmező Creative Commons License 2015.01.05 0 0 1003

"Azért Einsteinnek voltak megérzései. Nyilván ha a fénysebesség határsebesség, ennek érvényesnek kell lennie a kvantumfizikára is."

 

Einstein csak bizonyos - általa körülírt jelenségek kapcsán feltételezte a fénysebesség határsebesség voltát.  (külön jelezte is, hogy feltételezése nem tarthat számot általános érvényre - hanem csak az általa taglalt speciális esetekben )

Előzmény: m0kus (1001)
protag0ras Creative Commons License 2015.01.04 0 0 1002

997 ábrái:

 

1. polarizátor nélkül ez látszik Ds-ben (az ábra szélén csak nem a diffrakció látszik? nem néztem át a kódot)

2. -

3. Dp elé behelyezett polarizátor esetén Dp és koincidencia adatok alapján Ds adatokból kihasított interferencia minta

4. ugyanaz mint 3. csak a Dp elé tett polarizátor 90 fokkal el van forgatva

 

Kérdezem, hogy jól értem-e a képeket és hogy a 2. mi.

Előzmény: m0kus (997)
m0kus Creative Commons License 2015.01.04 0 0 1001

A képek koincidenciák vannak számolva.Csak egy foton létezik, de a két szubkvark kétfele megy.A koincidenciát mérő elektronika csatolja össze a két felet. Pontosan nem tudom hogy, de most ez mellékes.

A subquark modell szerint történik minden.  Csak egy foton detektálási valószínűséget számolok.

A görbe nem varázslattól javult meg, hanem azért, mert az összes lehetséges utat összegezni kell, és az legelőszőr nem volt helyesen felírva. Tehát a hullámtulajdonság sem tünt el, ugyan úgy kell a subquark mozgását számolni, mint bármi más részecskének a mozgását.

 

Az első ábrán a forgási irány normál és nincs radír.

A másodikon ellentétes a forgás. Meg van jelölve az útinfó. (rot_direction=-1.0;)

A harmadikon van radír.   (add_polarizer(&amp_ds,(0*45)/radian);)

A negyediken van radír.   (add_polarizer(&amp_ds,(1*45)/radian);)

A ötödiken van radír.   (add_polarizer(&amp_ds,(2*45)/radian);)

 

Azért Einsteinnek voltak megérzései. Nyilván ha a fénysebesség határsebbesség, ennek érvényesnek kell lennie a kvantumfizikára is.

 

Már ha valaki nem talál hibát ebben az egész levezetésben.

Előzmény: m0kus (999)
m0kus Creative Commons License 2015.01.04 0 0 1000

Ez már crackpot-

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


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


void pixel(int x,int y,int color)
{
    XSetForeground(dpy,gc,color);
    XDrawPoint(dpy, win, gc, x,y);
}
double sqr(double n) // x^2
{
    return n*n;
}
double doublerand() //random szam  0.0-tol 1.0-ig
{
    return (double)(rand()%10000)/10000.0;
}



struct vec2d
{
    double x,y;
};
void add_amp(vec2d *v,double phase,double a1,double a2)
{
    v->x += sin(phase)*a1;
    v->y += cos(phase)*a2;
};
void add_polarizer(vec2d *v,double phase)
{
    v->x *= cos(phase);
    v->y *= sin(phase);
};
double probalbility(vec2d *v)
{
    return (sqr(v->x) + sqr(v->y));
}


int main()
{
    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; }



    for(int x=0;x<400;x++)    
    {
        pixel(x,500,0x008800);
        pixel(x,300,0x008800);
        pixel(x,100,0x008800);
    }
    
    

    for(int ds_x=0;ds_x<400;ds_x++)//Ds position  -+4mm    
    {
        int photon_counter=0;
        int maxphoton=550;
        int maxwide=20;
        
        for(int p=0;p<maxphoton;p++)// max number of photon
        {
            double phase_a=M_PI*2*doublerand();
            double ds_distance=1250.0-420.0;//mm  125-42 cm
            double ds_distance2=980.0+420.0;//mm  visszafele a restol BBO-ig + dp_distance
            double dp_distance=980.0; //98 cm
            double wavelength=702.2e-6;//mm      e-9m
            double k=2.0*M_PI/wavelength;
            vec2d amp_dp,amp_ds;
            amp_dp.x=0;
            amp_dp.y=0;
            amp_ds.x=0;
            amp_ds.y=0;



            ds_distance+=0.0;
            double hole_dist=0.2;//0.2
            double hole_wide=0.2;//200 micrometer wide   
            int hole_side=(rand()%1000)/500;//vagy a) vagy b) mert a masik Dp fele megy

            double ds_pos=4.0*(double)(ds_x-200)/200.0;//+-4mm     Ds position

            for(int w=0;w<maxwide;w++)//slit wide
            {
            double hole1x=hole_dist/2.0 + hole_wide*(double)w/maxwide;//hole
            double dist1=sqrt(sqr(ds_pos - hole1x) + sqr(ds_distance));
            double dist1b=sqrt(sqr(ds_pos - hole1x) + sqr(ds_distance2));//backward
            double hole2x=-hole_dist/2.0 - hole_wide*(double)w/maxwide;
            double dist2=sqrt(sqr(ds_pos - hole2x) + sqr(ds_distance));            
            double dist2b=sqrt(sqr(ds_pos - hole2x) + sqr(ds_distance2));            


            double rot_direction=-1.0;// +-1
//Dp side
            dp_distance+=0.0;//hatrebb?
            //ha Ds normaliranyu, ez forditott
            if(hole_side==0) add_amp(&amp_ds,    phase_a + dp_distance*k + dist1b*k + M_PI,0.5, 0.5*rot_direction);
            if(hole_side==1) add_amp(&amp_ds,    phase_a + dp_distance*k + dist2b*k + M_PI,0.5, 0.5);//normal            
//Ds side            
            if(hole_side==0) add_amp(&amp_ds,    phase_a + dist1*k ,0.5, 0.5);// normal
            if(hole_side==1) add_amp(&amp_ds,    phase_a + dist2*k ,0.5, 0.5*rot_direction);// forditott forgasi irany
            }
            add_polarizer(&amp_ds,(0*45)/radian);//0 1 2*45 polarizator Dp elott

            amp_ds.x/=maxwide;//normalizalas
            amp_ds.y/=maxwide;
        
            if((probalbility(&amp_ds))>doublerand())//mindig csak egy foton van
                photon_counter+=1;
        }
        pixel(ds_x,500-photon_counter,0xffff00);
    }

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

m0kus Creative Commons License 2015.01.04 0 0 999

m0kus Creative Commons License 2015.01.04 0 0 998


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


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


void pixel(int x,int y,int color)
{
    XSetForeground(dpy,gc,color);
    XDrawPoint(dpy, win, gc, x,y);
}
double sqr(double n) // x^2
{
    return n*n;
}
double doublerand() //random szam  0.0-tol 1.0-ig
{
    return (double)(rand()%10000)/10000.0;
}



struct vec2d
{
    double x,y;
};
void add_amp(vec2d *v,double phase,double a1,double a2)
{
    v->x += sin(phase)*a1;
    v->y += cos(phase)*a2;
};
void add_polarizer(vec2d *v,double phase)
{
    v->x *= cos(phase);
    v->y *= sin(phase);
};
double probalbility(vec2d *v)
{
    return (sqr(v->x) + sqr(v->y));
}


int main()
{
    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; }



    for(int x=0;x<400;x++)    
    {
        pixel(x,500,0x008800);
        pixel(x,300,0x008800);
        pixel(x,100,0x008800);
    }
    
    

    for(int ds_x=0;ds_x<400;ds_x++)//Ds position  -+4mm    
    {
        int photon_counter=0;
        int maxphoton=400;//1500;
        int maxwide=20;
        
        for(int p=0;p<maxphoton;p++)// max number of photon
        {
            double phase_a=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;
            vec2d amp_dp,amp_ds;
            amp_dp.x=0;
            amp_dp.y=0;
            amp_ds.x=0;
            amp_ds.y=0;



            ds_distance+=0.0;
            double hole_dist=0.2;//0.2
            double hole_wide=0.2;//200 micrometer wide   
            int hole_side=(rand()%1000)/500;//vagy a) vagy b) mert a masik Dp fele megy

            double ds_pos=4.0*(double)(ds_x-200)/200.0;//+-4mm     Ds position

            for(int w=0;w<maxwide;w++)//slit wide
            {
                double hole1x=hole_dist/2.0 + hole_wide*(double)w/maxwide;//hole
                double dist1=sqrt(sqr(ds_pos - hole1x) + sqr(ds_distance));
                double hole2x=-hole_dist/2.0 - hole_wide*(double)w/maxwide;
                double dist2=sqrt(sqr(ds_pos - hole2x) + sqr(ds_distance));            

                dp_distance+=0.0;//hatrebb?
    //            add_amp(&amp_dp,    phase_a + dp_distance*k,0.5,0.5);

                add_amp(&amp_ds,    phase_a + dist1*k,0.5,0.5);
//                add_amp(&amp_ds,    phase_a + dist2*k,0.5,0.5);// normal forgasi irany
                add_amp(&amp_ds,    phase_a + dist2*k,0.5,-0.5);// forditott forgasi irany
            }
//            add_polarizer(&amp_dp,(2*45)/radian);//0 1 2*45 polarizator Dp elott
            add_polarizer(&amp_ds,(2*45)/radian);//0 1 2*45 polarizator Ds elott
            
            amp_ds.x/=maxwide;//normalizalas
            amp_ds.y/=maxwide;
            amp_dp.x/=maxwide;//normalizalas
            amp_dp.y/=maxwide;
            
        
            if((probalbility(&amp_ds))>doublerand())//csak Ds!!!
                photon_counter+=1;
        }
        pixel(ds_x,500-photon_counter,0xffff00);
    }

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

m0kus Creative Commons License 2015.01.04 0 0 997

 

 

m0kus Creative Commons License 2015.01.04 0 0 996

Azért nem teljes az amit írtál.

Mint írtam, a két részhalmaz független egymástól. Nem a Ds "részhalmazát" bontod fel.

 

Hát nem egyszerű szavakkal megfogalmazni egy ilyen összetett eseményrendszert.

Előzmény: m0kus (995)
m0kus Creative Commons License 2015.01.04 0 0 995

"Itt az utolsó mondatodra azt mondanám, hogy nem tudja. Mert nem kell tudnia. Ugyan az van Ds-ben koincidencia számlálóval, anélkül, mindig. Egyszerű haranggörbe. Bármit csinálhatok a p-ágban, Ds -t nem érdekli. Csak annyi a különbség, hogy utólag két interferencia mintára tudom bontani a Ds ábrát. Szerintem. Nem így van? Akkor hogyan?"

 

Egy nappal ezelőtt azt írtam volna, hogy nincs igazad.

Most azt kell mondanom, hogy igazad van.

 

Einstein nyert, nincs távolhatás. Vagyis most úgy látszik.

m0kus Creative Commons License 2015.01.04 0 0 994

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

857.

 

"

"És egy egymondatos kérdés a végére, csak mert annyira alapvető kérdés: ha a Ds-beli összes becsapódást nézem, akkor mindig ugyanazt látom függetlenül a Dp ágban történtektől?"

 

Ebben a kérdésben több buktató is van, ami kétértelművé teheti akár a ráadott válaszokat is.

Egyik részről, soha nem látod ugyanazt, a fotonok mindig máshova csapódnak. Olyan értelemben ugyanazt látod, hogy soha nincs interferencia.

Egy nappal ezelőtt azt írtam volna,  Dp ágbeli történésektől függ a Ds fotonok számunkra láthatatlan tulajdonságainak eloszlása. Ezt sugallja a QM.

 

De az egész nem ilyen egyszerű.

A többit nem ide írom, mert nem akarok crackpot gondolatokat írni egy konzervatív topikba.

"

 

Nos, hogy néz ki ez az egész a subquark modellben?

Az előbb már leírtam a három lehetséges esetet. 

A) fél foton és B) Dp fele          

A) fél foton és B) Ds fele

A) fél foton Dp fele és B) Ds fele 

 

A Ds önálló interferencia/nem interferencia képét a második eset adja meg.

Az entangled mérést viszont a harmadik eset. Igazából a két halmaz független egymástól, pont úgy, ahogy a QM számolási módszere sejtette.

 

 

m0kus Creative Commons License 2015.01.04 0 0 993

Sokak nagy bosszúságára visszatért az időbeli visszahatás.

Legalábbis a crackpot fizikába. (Egyenlőre)

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


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


void pixel(int x,int y,int color)
{
    XSetForeground(dpy,gc,color);
    XDrawPoint(dpy, win, gc, x,y);
}
double sqr(double n) // x^2
{
    return n*n;
}
double doublerand() //random szam  0.0-tol 1.0-ig
{
    return (double)(rand()%10000)/10000.0;
}



struct vec2d
{
    double x,y;
};
void add_amp(vec2d *v,double phase,double a1,double a2)
{
    v->x += sin(phase)*a1;
    v->y += cos(phase)*a2;
};
void add_polarizer(vec2d *v,double phase)
{
    v->x *= cos(phase);
    v->y *= sin(phase);
};
double probalbility(vec2d *v)
{
    return (sqr(v->x) + sqr(v->y));
}


int main()
{
    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; }



    for(int x=0;x<400;x++)    
    {
        pixel(x,500,0x008800);
        pixel(x,300,0x008800);
        pixel(x,100,0x008800);
    }
    
    

    for(int ds_x=0;ds_x<400;ds_x++)//Ds position  -+4mm    
    {
        int photon_counter=0;
        int maxphoton=400;
        
        for(int w=0;w<maxphoton;w++)//slit wide and max number of photon
        {
            double phase_a=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;
            vec2d amp_dsdp;
            amp_dsdp.x=0;
            amp_dsdp.y=0;



            ds_distance+=0.0;
            double hole_dist=0.2;//0.2
            double hole_wide=0.2;//200 micrometer wide   
            int hole_side=(rand()%1000)/500;//vagy a) vagy b) mert a masik Dp fele megy

            double ds_pos=4.0*(double)(ds_x-200)/200.0;//+-4mm     Ds position
            double hole1x=hole_dist/2.0 + hole_wide*(double)w/maxphoton;//hole
            double dist1=sqrt(sqr(ds_pos - hole1x) + sqr(ds_distance));
            double hole2x=-hole_dist/2.0 - hole_wide*(double)w/maxphoton;
            double dist2=sqrt(sqr(ds_pos - hole2x) + sqr(ds_distance));            


//Dp side
            dp_distance+=0.0;//hatrebb?
#if 1
//   ha az egyik fel megy  Ds - res - radir - Dp
//akkor a  masik fel megy  Dp - radir - res - Ds
            if(hole_side==0) add_amp(&amp_dsdp,    phase_a + dp_distance*k,0.5,-0.5);//ha Ds normaliranyu, ez forditott
            if(hole_side==1) add_amp(&amp_dsdp,    phase_a + dp_distance*k,0.5, 0.5);//normal            
//        add_polarizer(&amp_dsdp,(3*45)/radian);//3 5 7*45 polarizator Dp elott

//Ds side            
            if(hole_side==0) add_amp(&amp_dsdp,    phase_a + dist1*k,0.5, 0.5);// normal
            if(hole_side==1) add_amp(&amp_dsdp,    phase_a + dist2*k,0.5,-0.5);// forditott forgasi irany
#else
//csak a resek fele megy a ket fel foton
            add_amp(&amp_dsdp,    phase_a + dist1*k,0.5,0.5);
            add_amp(&amp_dsdp,    phase_a + dist2*k,0.5,0.5);// normal forgasi irany
//            add_amp(&amp_dsdp,    phase_a + dist2*k,0.5,-0.5);// forditott forgasi irany
#endif

            if((probalbility(&amp_dsdp))>doublerand())//mindig csak egy foton van
                photon_counter+=1;
        }
        pixel(ds_x,500-photon_counter,0xffff00);
    }

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

Előzmény: m0kus (989)
m0kus Creative Commons License 2015.01.04 0 0 992

megijed

Na igen, az internetezés káros harásai

Előzmény: m0kus (991)
m0kus Creative Commons License 2015.01.04 0 0 991

Nincs időbeli visszahatás?

 

Sokszor írtam, hogy valami miatt szerintem Feynman-Wheeler elmélet a helyes. Hogy miért? Sok olyan dolog történt velem, ami csak egyféleképp magyarázható: az emberi agy néha félelmetes pontossággal "megjósól" véletlenszerű eseményeket.

Aki egy ilyen nagy pontosságú élményt előszőr átél, az megilyed, annyira megmagyarázhatatlan. Huszadjára már nem az.

 

Nos kijavítható a hiba, és pont az időbeli megfordítással. De ez sejthető volt, ugyanis a subquark elmélet szerint a foton két subquarkja ellentétes irányba mozog az időben.

 

Miután a googlen fenntlesz, ide is felteszem a megoldást.

 

Előzmény: m0kus (985)
m0kus Creative Commons License 2015.01.04 0 0 990

A) fél foton Dp-be másik B) Ds-be felső résen, vagy fordítva

A) fél foton Dp-be másik B) Ds-be alsó résen, vagy fordítva

A) fél foton Ds-be alsó résen másik B) Ds-be felső résen, vagy fordítva

 

 

Előzmény: m0kus (989)
m0kus Creative Commons License 2015.01.04 0 0 989

Az első hiba nem is hiba. Ugyanis azt gondolná a halandó, hogy három eset van.

A) fél foton Dp-be másik B) Ds-be felső résen, vagy fordítva

A) fél foton Dp-be másik B) Ds-be alsó résen, vagy fordítva

A) fél foton Ds-be alsó résen másik B) Ds-be alsó résen, vagy fordítva

 

Ekkor az amplitudók nem felelnének meg, ugyanis az első két esetbe több foton detektálódik, mint a harmadikban, ami nem lehet.

 

Szerencsére ez a logika hibás.

Ugyan három eset lehetséges, de azok mások.

A) fél foton és B) Dp fele          

A) fél foton és B) Ds fele

A) fél foton Dp fele és B) Ds fele  

 

Az bázis interferenciát a második eset adja, az entanglement csak a harmadik esetben jön létre, és a két esetben a fotonszám megegyezik.

 

 

A második hiba már problémás, radír nélkül is van interferencia.

De alapszabály, soha nem feladni...

 

 

Előzmény: m0kus (985)
m0kus Creative Commons License 2015.01.03 0 0 988

 

m0kus Creative Commons License 2015.01.03 0 0 987
m0kus Creative Commons License 2015.01.03 0 0 986

 dp_distance+=0.0;//hatrebb?

 

Természetes, hogy tologathatom a Dp detektort bárhova, semmi köze a Ds detektor detektákási idelyéhez.

 

Előzmény: m0kus (984)
m0kus Creative Commons License 2015.01.03 0 0 985

A megoldás nem 100% de van interferencia minta.A problémát az okozhatja, hogy én Dp fele is forgó vektorral számolok.

A fél-foton megoldásnál azért tőrlődik a útvonal infó, mert csak az egyik foton lesz megjelölve a másik nincs és nem is volt megjelölve.

 

Nincs távolbahatás, nincs időbeli visszahatás.

De van fél foton.

Lehet elmélkedni...

Előzmény: m0kus (984)
m0kus Creative Commons License 2015.01.03 0 0 984


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


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


void pixel(int x,int y,int color)
{
    XSetForeground(dpy,gc,color);
    XDrawPoint(dpy, win, gc, x,y);
}
double sqr(double n) // x^2
{
    return n*n;
}
double doublerand() //random szam  0.0-tol 1.0-ig
{
    return (double)(rand()%10000)/10000.0;
}



struct vec2d
{
    double x,y;
};
void add_amp(vec2d *v,double phase,double a1,double a2)
{
    v->x += sin(phase)*a1;
    v->y += cos(phase)*a2;
};
void add_polarizer(vec2d *v,double phase)
{
    v->x *= cos(phase);
    v->y *= sin(phase);
};
double probalbility(vec2d *v)
{
    return (sqr(v->x) + sqr(v->y));
}


int main()
{
    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; }



    for(int x=0;x<400;x++)    
    {
        pixel(x,500,0x008800);
        pixel(x,300,0x008800);
        pixel(x,100,0x008800);
    }
    
    

    for(int ds_x=0;ds_x<400;ds_x++)//Ds position  -+4mm    
    {
        int photon_counter=0;
        int maxphoton=400;
        
        for(int w=0;w<maxphoton;w++)//slit wide and max number of photon
        {
            double phase_a=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;
            vec2d amp_dsdp;
            amp_dsdp.x=0;
            amp_dsdp.y=0;



            ds_distance+=0.0;
            double hole_dst=0.2;//0.2
            double hole_wide=0.2;//200 micrometer wide   
            


//Dp side
            dp_distance+=0.0;//hatrebb?
            add_amp(&amp_dsdp,    phase_a + dp_distance*k,0.5,0.5);
            add_polarizer(&amp_dsdp,3*45.0/radian);//polarizator Dp elott


//Ds side            
            int hole_side=(rand()%1000)/500;//vagy a) vagy b) mert a masik Dp fele megy
            double ds_pos=4.0*(double)(ds_x-200)/200.0;//+-4mm     Ds position
//Ds side a)Hole
            double holex=hole_dst/2.0 + hole_wide*(double)w/maxphoton;//hole
            double t=sqrt(sqr(ds_pos - holex) + sqr(ds_distance));
            if(hole_side==0) add_amp(&amp_dsdp,    phase_a + t*k,0.5,0.5);

//Ds side b)Hole
            holex=-hole_dst/2.0 - hole_wide*(double)w/maxphoton;
            t=sqrt(sqr(ds_pos - holex) + sqr(ds_distance));            
            if(hole_side==1) add_amp(&amp_dsdp,    phase_a + t*k,0.5,-0.5);// forditott forgasi irany


            if((probalbility(&amp_dsdp))>doublerand())
                photon_counter+=1;
        }
        pixel(ds_x,500-photon_counter,0xffff00);
    }

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

m0kus Creative Commons License 2015.01.03 0 0 983

Tényleg, mi van a fél fotonnal?

Ekkor nem két valószínűséget kell számolni, hanem egyet ugyan úgy, mint az egy foton- két rés esetében. Az eltérés csak annyi, hogy az egyik fél mehet a Dp fele, a másik a Ds fele valamelyik résen. Ekkor "közös" a fotondetektálás. Valójában egyetlen foton két feléről beszélhetünk.

A többi eset kiesik, hisz amikor a két résen megy át a két fél, akkor nem megy semmi a Dp fele.

 

 

m0kus Creative Commons License 2015.01.03 0 0 982

 

Itt az elletétes fázis 90 fokos radir polarizátorral. A program a radírt a két rés után rakja be. így van értelme az egésznek. Az interferencia minta szinte teljesen megegyezik a PDF-ben található ábrákkal.

A valóság annyival dúrvább, hogy itt a polarizátort betehetem a másik ágba is.

m0kus Creative Commons License 2015.01.03 0 0 981

Miért esik felére a radírnál a fotonszám? Mert a radír egy egyszerű polárszűrő, márpedig alap, hogy a polarizátor a polarizálatlan fény 50%-át engedi át.

m0kus Creative Commons License 2015.01.03 0 0 980

1)

#if 0
            add_amp(&amp_dp,    phase_a + dp_distance*k,0.5,0.5);
            add_amp(&amp_dp,    phase_a + dp_distance*k,0.5,0.5);
            add_polarizer(&amp_dp,0.0/radian);//polarizator Dp elott
            
            if((probalbility(&amp_dp))>doublerand())
#endif       

 

Ez a Dp ág, igazából itt felesleges, mert klasszikusan nem szimulálható az eset.

kikapcsolva #if 0

bekapcsolva #if 1

 

 

2)

//    add_polarizer(&amp_ds,0.0/radian);//0 vagy 45 vagy 90,      polarizator a res utan     Ds elott

A két perjelet kiszedve működésbe lép a polarizátor. Lehet állítani a szögét (0.0/radian).

0 és 90 fokbál megfigyelhető a PDF-ben vázolt fáziseltérés az görbék közt.

Előzmény: m0kus (977)
m0kus Creative Commons License 2015.01.03 0 0 979

A képek sorba

1.) egy rés nyitva     2.) kettő nyitva azonos forgási iránnyal

3.) két rés nyitva ellentétes forgással  4.) két rés nyitva ellentétes forgással + Ds előtt radír polarizátor

5.) radír polarizátor a Dp előtt, de klasszikusan nyilván nincs interferencia minta.

 

 

A program egyszerű forgó vektorral számol, nem akartam bonyolítani az egészet komplex számokkal. De Feynman is így mutatta be a QED-et.

 

Az 1. és a 2. ábra jól mutatja, hogy 2 rés esetén a maximum fotonmennyiség a konstruktív helyeken 4 szeres.

 

Az ábra szélein azért nem megy le nullára a detektálás, mert nem egy keskeny lézernyalábbal számoltam. Lehetne bonyolítani, de felesleges. A lényeg jól látszik.

 

Referencia

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

 

Kapcsolódó téma.

844.

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

m0kus Creative Commons License 2015.01.03 0 0 978

m0kus Creative Commons License 2015.01.03 0 0 977



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


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


void pixel(int x,int y,int color)
{
    XSetForeground(dpy,gc,color);
    XDrawPoint(dpy, win, gc, x,y);
}
double sqr(double n) // x^2
{
    return n*n;
}
double doublerand() //random szam  0.0-tol 1.0-ig
{
    return (double)(rand()%10000)/10000.0;
}



struct vec2d
{
    double x,y;
};
void add_amp(vec2d *v,double phase,double a1,double a2)
{
    v->x += sin(phase)*a1;
    v->y += cos(phase)*a2;
};
void add_polarizer(vec2d *v,double phase)
{
    v->x *= cos(phase);
    v->y *= sin(phase);
};
double probalbility(vec2d *vec2d)
{
    return (sqr(vec2d->x) + sqr(vec2d->y));
}


int main()
{
    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; }



    for(int x=0;x<400;x++)    
    {
        pixel(x,500,0x008800);
        pixel(x,300,0x008800);
        pixel(x,100,0x008800);
    }
    
    

    for(int ds_x=0;ds_x<400;ds_x++)//Ds position  -+4mm    
    {
        int photon_counter=0;
        int maxphoton=400;
        
        for(int w=0;w<maxphoton;w++)//slit wide and max number of photon
        {
            double phase_a=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;
            vec2d amp_ds,amp_dp;
            amp_ds.x=0;
            amp_ds.y=0;
            amp_dp.x=0;
            amp_dp.y=0;



            ds_distance+=0.0;
            double hole_dst=0.2;//0.2
            double hole_wide=0.2;//200 micrometer wide   
            

            double ds_pos=4.0*(double)(ds_x-200)/200.0;//+-4mm     Ds position
            double holex=hole_dst/2.0 + hole_wide*(double)w/maxphoton;//hole
            double t=sqrt(sqr(ds_pos - holex) + sqr(ds_distance));
            add_amp(&amp_ds,    phase_a + t*k,0.5,0.5);

            holex=-hole_dst/2.0 - hole_wide*(double)w/maxphoton;
            t=sqrt(sqr(ds_pos - holex) + sqr(ds_distance));            
            add_amp(&amp_ds,    phase_a + t*k,0.5,0.5);// normal forgasi irany
//            add_amp(&amp_ds,    phase_a + t*k,0.5,-0.5);// forditott forgasi irany
//    add_polarizer(&amp_ds,0.0/radian);//0 vagy 45 vagy 90,      polarizator a res utan     Ds elott
#if 0
            add_amp(&amp_dp,    phase_a + dp_distance*k,0.5,0.5);
            add_amp(&amp_dp,    phase_a + dp_distance*k,0.5,0.5);
            add_polarizer(&amp_dp,0.0/radian);//polarizator Dp elott
            
            if((probalbility(&amp_dp))>doublerand())
#endif            
            if((probalbility(&amp_ds))>doublerand())
                photon_counter+=1;
        }
        pixel(ds_x,500-photon_counter,0xffff00);
    }

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

dochow Creative Commons License 2015.01.01 0 0 976

"Ha MINDEN entangled fotonpár EGYFORMA polarizációjú lenne"

Talán inkább így

Előzmény: dochow (975)
dochow Creative Commons License 2015.01.01 0 0 975

Polarizáljunk két fénysugarat egymásra 90 fokban. Tegyünk mindkettő elé a polarizálciós irányukra 45 fokban álló polarizátorokat. Tudjuk, hogy mindkettőn a fény 50%-a fog átmenni. A közös detektálás 25% lesz.

Ez egy fontos lépés a megértés fele. Miért? Mert be kell látni, hogy ha a BBO kristályból kilépő fotonopár polarizáltsága véletlenszerű irányú, de mindig egymásra merőleges, akkor mindig előfordulhat olyan eset, mint a fenti. Mindenféle polarizátor állásnál kell valamennyi fotontpárt detektálni.

 

Csakhogy az entangled fotonoknál az egyenlet 0.5cos2(p1-p2) ami 90 foknál 0 közös fotondetektálást ad.

(merőleges esetben 0.5sin2(p1-p2)) ami 0 fokra ad 0 valószínűséget.)

Márpedig ez logikailag nem egyeztethető össze a Malus-törvénnyel és a klasszikus fény viselkedésével.

 

 

Ha az entangled fotonpár fix polarizációjú lenne, akkor nem lenne gond, csakhogy ez könnyen ellenőrízhető egy forgatott polarizátorra. A fotonoknak nincs polarizációs irányuk amikor a BBO kristályból kilépnek.

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