Keresés

Ezt a részt azért hagytam benne, hogy ellenőrízni lehessen a QWP helyes működését.

+-45 foknál cirkulárisan polarizált lesz, alatta elliptikus. Az előjelcsere megfordítja a forgási irányt, vagyis helyes a szimuláció.

        double dist1=0.0;
        for(int p=0;p<1000;p++)//quarterwaveplate
        {
            vec2d amp_dp,amp_ds;
            add_quarterwaveplate(&amp_ds,0.0/radian , dist1*M_PI/100.0,-45.0/radian,0.5, 0.5,0.0);

            line(200,200,200+200.0*amp_ds.x,200+200.0*amp_ds.y,0x00ff00);
            dist1+=5.0;
            
            XFlush(dpy);
            getchar();
        }

Ugye a programban van egy látszólagos apró hiba. A két foton nem a detektoroknál merőleges egymásra, hanem a radírnál, és a QWP-nél.

Lehet, hogy ez egy hiba, de szerintem nem az.

Ugyanis ki lehet próbálni, mi van akkor, ha a méréskor merőlegesek egymásra a fotonok. Csak ennyit kell betenni ..

amp_dp.x= amp_ds.y;

amp_dp.y=-amp_ds.x;

...ez elé a sor elé..

   if(eraser_on) add_polarizer(&amp_dp,eraser_alpha);// polarizer before Dp

Ugyan működik a radír, de az amplitudó így túl kicsi lesz minden esetben.

így már sokkal jobb.

Négy eset lehetséges a szubkvarkoknak megfelelően.

#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);
}
void line(int x1,int y1,int x2,int y2,int color)
{
    XSetForeground(dpy,gc,color);
    XDrawLine(dpy, win, gc, x1,y1,x2,y2);
}
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;
    
    vec2d() {x=0;y=0;}
};
void add_amp(vec2d *v,double phase,double ax,double ay)
{
    v->x += sin(phase)*ax;
    v->y += cos(phase)*ay;
};
void add_polarizer(vec2d *v,double phase)
{
    v->x *= sin(phase);
    v->y *= cos(phase);
};
double dot(vec2d *v1,vec2d *v2)
{
    return v1->x*v2->x + v1->y*v2->y;
}
void add_quarterwaveplate(vec2d *v,double phase,double dist,double qwp,double ax,double ay,double dphase)
{
    vec2d axis_fast,axis_slow,input_wave;
    
    add_amp(&axis_fast,qwp,1.0,1.0);
    add_amp(&axis_slow,qwp+90.0/radian,1.0,1.0);
    add_amp(&input_wave,phase,1.0,1.0);

    double amp_fast=dot(&axis_fast,&input_wave);
    double amp_slow=dot(&axis_slow,&input_wave);
    
    amp_fast=cos(dist+dphase)*amp_fast;
    amp_slow=sin(dist+dphase)*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)*ay;
};
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=600;
        int maxwide=10;

        int qwplate_on=0;
        int eraser_on=0;
        double eraser_alpha=0*45.0/radian;//0,1,2

//        if(eraser_on) maxphoton*=4;//lathatosag
        
        
        for(int p=0;p<maxphoton;p++)// max number of photon
        {
            double dphase=M_PI*2*doublerand();
#if 1
            double photon_pol_a=M_PI*2*doublerand();
            double photon_pol_b=photon_pol_a+M_PI/2;
#else            
            double photon_pol_a=0; //polarized lightsource
            if(doublerand()>0.5) photon_pol_a=M_PI/2;
            double photon_pol_b=photon_pol_a+M_PI/2;
            if(doublerand()>0.5) photon_pol_b=photon_pol_a-M_PI/2;
#endif


            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;

            if(eraser_on)
            {
                if(doublerand()>0.5)
                {
                    photon_pol_a=eraser_alpha;//backward causality
                    photon_pol_b=eraser_alpha+90.0/radian;
                }
                else                 
                {
                    photon_pol_a=eraser_alpha+90.0/radian;
                    photon_pol_b=eraser_alpha;
                }
            }


            double hole_dist=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
            int side=rand()%4;

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


                if(qwplate_on)
                {
                    if(side==0)
                    {
                    add_amp(&amp_dp,photon_pol_a ,0.5,0.5);
                    add_amp(&amp_dp,photon_pol_a ,0.5,0.5);

                    add_quarterwaveplate(&amp_ds,photon_pol_b , dist1*k,-45.0/radian,0.5, 0.5,dphase);
                    add_quarterwaveplate(&amp_ds,photon_pol_b , dist2*k, 45.0/radian,0.5, 0.5,dphase);
                    }
                    if(side==1)
                    {
                    add_amp(&amp_dp,photon_pol_b ,0.5,0.5);
                    add_amp(&amp_dp,photon_pol_b ,0.5,0.5);

                    add_quarterwaveplate(&amp_ds,photon_pol_a , dist1*k,-45.0/radian,0.5, 0.5,dphase);
                    add_quarterwaveplate(&amp_ds,photon_pol_a , dist2*k, 45.0/radian,0.5, 0.5,dphase);
                    }
                    if(side==2)
                    {
                    add_amp(&amp_dp,photon_pol_a ,0.5,0.5);
                    add_amp(&amp_dp,photon_pol_b ,0.5,0.5);

                    add_quarterwaveplate(&amp_ds,photon_pol_a , dist1*k,-45.0/radian,0.5, 0.5,dphase);
                    add_quarterwaveplate(&amp_ds,photon_pol_b , dist2*k, 45.0/radian,0.5, 0.5,dphase);
                    }
                    if(side==3)
                    {
                    add_amp(&amp_dp,photon_pol_b ,0.5,0.5);
                    add_amp(&amp_dp,photon_pol_a ,0.5,0.5);

                    add_quarterwaveplate(&amp_ds,photon_pol_b , dist1*k,-45.0/radian,0.5, 0.5,dphase);
                    add_quarterwaveplate(&amp_ds,photon_pol_a , dist2*k, 45.0/radian,0.5, 0.5,dphase);
                    }
                }
                else
                {
                    if(side==0)
                    {
                    add_amp(&amp_dp,photon_pol_a ,0.5,0.5);
                    add_amp(&amp_dp,photon_pol_a ,0.5,0.5);
                    add_amp(&amp_ds,photon_pol_b +dist1*k ,0.5,0.5);
                    add_amp(&amp_ds,photon_pol_b +dist2*k ,0.5,0.5);
                    }
                    if(side==1)
                    {
                    add_amp(&amp_dp,photon_pol_b ,0.5,0.5);
                    add_amp(&amp_dp,photon_pol_b ,0.5,0.5);
                    add_amp(&amp_ds,photon_pol_a +dist1*k ,0.5,0.5);
                    add_amp(&amp_ds,photon_pol_a +dist2*k ,0.5,0.5);
                    }
                    if(side==2)
                    {
                    add_amp(&amp_dp,photon_pol_a ,0.5,0.5);
                    add_amp(&amp_dp,photon_pol_b ,0.5,0.5);
                    add_amp(&amp_ds,photon_pol_a +dist1*k ,0.5,0.5);
                    add_amp(&amp_ds,photon_pol_b +dist2*k ,0.5,0.5);
                    }
                    if(side==3)
                    {
                    add_amp(&amp_dp,photon_pol_b ,0.5,0.5);
                    add_amp(&amp_dp,photon_pol_a ,0.5,0.5);
                    add_amp(&amp_ds,photon_pol_b +dist1*k ,0.5,0.5);
                    add_amp(&amp_ds,photon_pol_a +dist2*k ,0.5,0.5);
                    }
                }
            }
            if(eraser_on) add_polarizer(&amp_dp,eraser_alpha);// polarizer before Dp
            
            amp_dp.x/=maxwide;//normalized
            amp_dp.y/=maxwide;
            amp_ds.x/=maxwide;
            amp_ds.y/=maxwide;


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

/*
        double dist1=0.0;
        for(int p=0;p<1000;p++)//quarterwaveplate
        {
            vec2d amp_dp,amp_ds;
            add_quarterwaveplate(&amp_ds,0.0/radian , dist1*M_PI/100.0,-45.0/radian,0.5, 0.5,0.0);

            line(200,200,200+200.0*amp_ds.x,200+200.0*amp_ds.y,0x00ff00);
            dist1+=5.0;
            
            XFlush(dpy);
            getchar();
        }*/

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

Ki lehet próbálni, a Ds-en önmagában nincs interferencia.

#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);
}
void line(int x1,int y1,int x2,int y2,int color)
{
    XSetForeground(dpy,gc,color);
    XDrawLine(dpy, win, gc, x1,y1,x2,y2);
}
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;
    
    vec2d() {x=0;y=0;}
};
void add_amp(vec2d *v,double phase,double ax,double ay)
{
    v->x += sin(phase)*ax;
    v->y += cos(phase)*ay;
};
void add_polarizer(vec2d *v,double phase)
{
    v->x *= sin(phase);
    v->y *= cos(phase);
};
double dot(vec2d *v1,vec2d *v2)
{
    return v1->x*v2->x + v1->y*v2->y;
}
void add_quarterwaveplate(vec2d *v,double phase,double dist,double qwp,double ax,double ay,double dphase)
{
    vec2d axis_fast,axis_slow,input_wave;
    
    add_amp(&axis_fast,qwp,1.0,1.0);
    add_amp(&axis_slow,qwp+90.0/radian,1.0,1.0);
    add_amp(&input_wave,phase,1.0,1.0);

    double amp_fast=dot(&axis_fast,&input_wave);
    double amp_slow=dot(&axis_slow,&input_wave);
    
    amp_fast=cos(dist+dphase)*amp_fast;
    amp_slow=sin(dist+dphase)*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)*ay;
};
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;
        int maxwide=10;

        int qwplate_on=1;
        int eraser_on=1;
        double eraser_alpha=22.5/radian;
//        double eraser_alpha=(-22.5)/radian;

//        if(eraser_on) maxphoton*=4;//lathatosag
        
        
        
        for(int p=0;p<maxphoton;p++)// max number of photon
        {
            double dphase=M_PI*2*doublerand();
#if 1
            double photon_pol_a=M_PI*2*doublerand();
            double photon_pol_b=photon_pol_a+M_PI/2;
#else            
            double photon_pol_a=0; //polarized lightsource
            if(doublerand()>0.5) photon_pol_a=M_PI/2;
            double photon_pol_b=photon_pol_a+M_PI/2;
            if(doublerand()>0.5) photon_pol_b=photon_pol_a-M_PI/2;
#endif


            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;

            if(eraser_on)
            {
                if(doublerand()>0.5)
                {
                    photon_pol_a=eraser_alpha;//backwark causality
                    photon_pol_b=eraser_alpha+90.0/radian;
                }
                else                 
                {
                    photon_pol_a=eraser_alpha+90.0/radian;
                    photon_pol_b=eraser_alpha;
                }
            }


            double hole_dist=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
            int side=rand()%2;

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


                if(qwplate_on)
                {
                    if(side==0)
                    {
                    add_amp(&amp_dp,photon_pol_a ,0.5,0.5);
                    add_amp(&amp_dp,photon_pol_a ,0.5,0.5);

                    add_quarterwaveplate(&amp_ds,photon_pol_b , dist1*k,-45.0/radian,0.5, 0.5,dphase);
                    add_quarterwaveplate(&amp_ds,photon_pol_b , dist2*k, 45.0/radian,0.5, 0.5,dphase);
                    }
                    else
                    {
                    add_amp(&amp_dp,photon_pol_b ,0.5,0.5);
                    add_amp(&amp_dp,photon_pol_b ,0.5,0.5);

                    add_quarterwaveplate(&amp_ds,photon_pol_a , dist1*k,-45.0/radian,0.5, 0.5,dphase);
                    add_quarterwaveplate(&amp_ds,photon_pol_a , dist2*k, 45.0/radian,0.5, 0.5,dphase);
                    }
                }
                else
                {
                    add_amp(&amp_dp,photon_pol_a ,0.5,0.5);
                    add_amp(&amp_dp,photon_pol_a ,0.5,0.5);
                    add_amp(&amp_ds,photon_pol_b +dist1*k ,0.5,0.5);
                    add_amp(&amp_ds,photon_pol_b +dist2*k ,0.5,0.5);
                }
            }
            if(eraser_on) add_polarizer(&amp_dp,eraser_alpha);// polarizer before Dp
            
            amp_dp.x/=maxwide;//normalized
            amp_dp.y/=maxwide;
            amp_ds.x/=maxwide;
            amp_ds.y/=maxwide;


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

/*
        double dist1=0.0;
        for(int p=0;p<1000;p++)//quarterwaveplate
        {
            vec2d amp_dp,amp_ds;
            add_quarterwaveplate(&amp_ds,0.0/radian , dist1*M_PI/100.0,45.0/radian,0.5, 0.5);

            line(200,200,200+200.0*amp_ds.x,200+200.0*amp_ds.y,0x00ff00);
            dist1+=5.0;
            
            XFlush(dpy);
            getchar();
        }
*/
    XFlush(dpy);
    getchar();
        
    return 0;
}

A visszaállított interferencia magassága negyede az eredetinek, de ha jól megnézzük, akkor a PDF-ben is közelítőleg ennyi:

200/400s   120/800s=60/400s

Igazából ez nem klasszikus megoldás a visszahatás miatt. Olyan értelemben viszont klasszikus, hogy nincs távolhatás, és nincs fénysebesség átlépés.

De mint a másik topikba már idézve lett, ez a megoldás nem ismeretlen a fizikusok számára:

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

http://www.sciencedaily.com/releases/2012/04/120423131902.htm

A PDF-ben található harang-görbe eredete ebben az esetben ismeretlen. De a probléma szemszögéből most lényegtelen. A radír visszaállítja az interferencia mintát, de csak akkor, ha ez a sor működik:

if(eraser_on) photon_pol_b=eraser_alpha;//backwark causality

Ezzel elérhető, hogy a Ds oldali QWP-re határozott polarizálságú fény jusson, így nem fog kialakulni cirkuláris polarizáltság, így lesz interferencia. 

Nyilván ha csak egyféle polarizáltságú lenne a QWP előtt a fény, akkor ez kimérhető lenne. A valóságban ez nem kimutatható, de ez a probléma egyszerűen megoldható azzal, hogy egyszer az egyik foton jön erre, másszor meg az erre merőleges polaritású. így már nem észrevehető fix polarizáltság, mégis helyes az eredmény.

Az interferencia-zaj kiesett a +dphase segítségével. Ez eltolja a hullámot, hogy ne mindig ugyan olyan fázisban induljon a QWP-ről. Ez okozta a képeken a zajt.

A quarterwaveplate függvény részletesebben. Adott két tengely, a gyors és a lassú. A lassú irányú komponense a hullámnak el fog tolódni 90 fokkal. (a fázisa). Ekkor a hullám forogni fog, ha addig polarizált volt. Ha a fény polarizációs iránya egybe esik a gyors tengellyel, akkor nincs lassú komponens, így nincs ami eltolódjon.

A gyors tengely:

    add_amp(&axis_fast,qwp,1.0,1.0);

A lassú:
    add_amp(&axis_slow,qwp+90.0/radian,1.0,1.0);

A bejövő fény, phase a polari
    add_amp(&input_wave,phase,1.0,1.0);

Ennek a két tengelyre eső komponense:
    double amp_fast=dot(&axis_fast,&input_wave);
    double amp_slow=dot(&axis_slow,&input_wave);
    

A két tengely irányú új hullám:
    amp_fast=cos(dist+dphase)*amp_fast;
    amp_slow=sin(dist+dphase)*amp_slow;//-+90 phase shift

A sin() hullám az ugyan az mint a cos(), de 90 fokkal el van tolva a fázisa.

És ezek összege:
    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)*ay;

#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);
}
void line(int x1,int y1,int x2,int y2,int color)
{
    XSetForeground(dpy,gc,color);
    XDrawLine(dpy, win, gc, x1,y1,x2,y2);
}
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;
    
    vec2d() {x=0;y=0;}
};
void add_amp(vec2d *v,double phase,double ax,double ay)
{
    v->x += sin(phase)*ax;
    v->y += cos(phase)*ay;
};
void add_polarizer(vec2d *v,double phase)
{
    v->x *= sin(phase);
    v->y *= cos(phase);
};
double dot(vec2d *v1,vec2d *v2)
{
    return v1->x*v2->x + v1->y*v2->y;
}
void add_quarterwaveplate(vec2d *v,double phase,double dist,double qwp,double ax,double ay,double dphase)
{
    vec2d axis_fast,axis_slow,input_wave;
    
    add_amp(&axis_fast,qwp,1.0,1.0);
    add_amp(&axis_slow,qwp+90.0/radian,1.0,1.0);
    add_amp(&input_wave,phase,1.0,1.0);

    double amp_fast=dot(&axis_fast,&input_wave);
    double amp_slow=dot(&axis_slow,&input_wave);
    
    amp_fast=cos(dist+dphase)*amp_fast;
    amp_slow=sin(dist+dphase)*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)*ay;
};
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;
        int maxwide=10;

        int qwplate_on=1;
        int eraser_on=1;
        double eraser_alpha=45.0/radian;
//        double eraser_alpha=-45.0/radian;
        
        for(int p=0;p<maxphoton;p++)// max number of photon
        {
            double dphase=M_PI*2*doublerand();
#if 1
            double photon_pol_a=M_PI*2*doublerand();
            double photon_pol_b=photon_pol_a+M_PI/2;
#else            
            double photon_pol_a=0; //polarized lightsource
            if(doublerand()>0.5) photon_pol_a=M_PI/2;
            double photon_pol_b=photon_pol_a+M_PI/2;
            if(doublerand()>0.5) photon_pol_b=photon_pol_a-M_PI/2;
#endif


            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;

            if(eraser_on) photon_pol_b=eraser_alpha;//backwark causality


            double hole_dist=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

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


                if(qwplate_on)
                {
                    add_amp(&amp_dp,photon_pol_a ,0.5,0.5);
                    add_amp(&amp_dp,photon_pol_a ,0.5,0.5);

                    add_quarterwaveplate(&amp_ds,photon_pol_b , dist1*k,-45.0/radian,0.5, 0.5,dphase);
                    add_quarterwaveplate(&amp_ds,photon_pol_b , dist2*k, 45.0/radian,0.5, 0.5,dphase);
                }
                else
                {
                    add_amp(&amp_dp,photon_pol_a ,0.5,0.5);
                    add_amp(&amp_dp,photon_pol_a ,0.5,0.5);
                    add_amp(&amp_ds,photon_pol_b +dist1*k ,0.5,0.5);
                    add_amp(&amp_ds,photon_pol_b +dist2*k ,0.5,0.5);
                }
            }
            if(eraser_on) add_polarizer(&amp_dp,eraser_alpha);// polarizer before Dp
            
            amp_dp.x/=maxwide;//normalized
            amp_dp.y/=maxwide;
            amp_ds.x/=maxwide;
            amp_ds.y/=maxwide;


            if((probalbility(&amp_dp))>doublerand())
            if((probalbility(&amp_ds))>doublerand())
                photon_counter+=1;
        }

        pixel(ds_x,500-photon_counter,0xffff00);
    }

/*
        double dist1=0.0;
        for(int p=0;p<1000;p++)//quarterwaveplate
        {
            vec2d amp_dp,amp_ds;
            add_quarterwaveplate(&amp_ds,0.0/radian , dist1*M_PI/100.0,45.0/radian,0.5, 0.5);

            line(200,200,200+200.0*amp_ds.x,200+200.0*amp_ds.y,0x00ff00);
            dist1+=5.0;
            
            XFlush(dpy);
            getchar();
        }
*/
    XFlush(dpy);
    getchar();
        
    return 0;
}

add_quarterwaveplate()

A kisérletezőknek azért leírom, hogy ez a függvény csak lineárisan polarizált bemenettel helyes. De ebben az esetben nem is kell más.

http://hyperphysics.phy-astr.gsu.edu/hbase/phyopt/quarwv.html

Namost a lambda 4-es lemez mostmár  helyesen működik, de az ábráról hiányzik az 1/3 zaj búrkológőrbéje, amire ráül az interferencia. Ezen még dolgozom.

De igy már van értelme az időbeli visszahatásnak, hiszen nem mindegy, hogy milyen az iránya a lineárisan polarizált fénynek, ami ráesik a QWP-re. Ha betesszük a radírt a Dp ágba, akkor a Ds ágban (néha?) a QWP-re a radir polarizátornak megfelelő irányú fény esik, vagy arra merőleges felváltva.

#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);
}
void line(int x1,int y1,int x2,int y2,int color)
{
    XSetForeground(dpy,gc,color);
    XDrawLine(dpy, win, gc, x1,y1,x2,y2);
}
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;
    
    vec2d() {x=0;y=0;}
};
void add_amp(vec2d *v,double phase,double ax,double ay)
{
    v->x += sin(phase)*ax;
    v->y += cos(phase)*ay;
};
void add_polarizer(vec2d *v,double phase)
{
    v->x *= sin(phase);
    v->y *= cos(phase);
};
double dot(vec2d *v1,vec2d *v2)
{
    return v1->x*v2->x + v1->y*v2->y;
}
void add_quarterwaveplate(vec2d *v,double phase,double dist,double qwp,double ax,double ay)
{
    vec2d axis_fast,axis_slow,input_wave;
    
    add_amp(&axis_fast,qwp,1.0,1.0);
    add_amp(&axis_slow,qwp+90.0/radian,1.0,1.0);
    add_amp(&input_wave,phase,1.0,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)*ay;
};
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;
        int maxwide=10;

        int qwplate_on=1;
        int eraser_on=1;
        double eraser_alpha=45.0/radian;
        
        for(int p=0;p<maxphoton;p++)// max number of photon
        {
#if 0
            double phase_a=M_PI*2*doublerand();
            double phase_b=phase_a+M_PI/2;
#else            
            double phase_a=0; //polarized lightsource
            if(doublerand()>0.5) phase_a=M_PI/2;
            double phase_b=phase_a+M_PI/2;
            if(doublerand()>0.5) phase_b=phase_a-M_PI/2;
#endif


            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;



            ds_distance+=0.0;
            double hole_dist=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

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


                add_amp(&amp_dp,phase_b ,0.5,0.5);
                add_amp(&amp_dp,phase_b ,0.5,0.5);

                if(qwplate_on)
                {
                    if(eraser_on) phase_a=eraser_alpha;
                    add_quarterwaveplate(&amp_ds,phase_a , dist1*k,-45.0/radian,0.5, 0.5);
                    add_quarterwaveplate(&amp_ds,phase_a , dist2*k, 45.0/radian,0.5, 0.5);
                }
                else
                {
                    add_amp(&amp_ds,phase_a +dist1*k ,0.5,0.5);
                    add_amp(&amp_ds,phase_a +dist2*k ,0.5,0.5);
                }
            }
            if(eraser_on) add_polarizer(&amp_dp,eraser_alpha);// polarizer before Dp

            
            amp_dp.x/=maxwide;//normalized
            amp_dp.y/=maxwide;
            amp_ds.x/=maxwide;
            amp_ds.y/=maxwide;


            if((probalbility(&amp_dp))>doublerand())
            if((probalbility(&amp_ds))>doublerand())
                photon_counter+=1;
        }

        pixel(ds_x,500-photon_counter,0xffff00);
    }

/*
        double dist1=0.0;
        for(int p=0;p<1000;p++)//quarterwaveplate
        {
            vec2d amp_dp,amp_ds;
            add_quarterwaveplate(&amp_ds,0.0/radian , dist1*M_PI/100.0,45.0/radian,0.5, 0.5);

            line(200,200,200+200.0*amp_ds.x,200+200.0*amp_ds.y,0x00ff00);
            dist1+=5.0;
            
            XFlush(dpy);
            getchar();
        }
*/
    XFlush(dpy);
    getchar();
        
    return 0;
}

Felesleges vitatkozni, minden attól függ, hogy mit definiálsz előbb. Ha a geometiát veszet alapnak, akkor a fény pályája azért görbül.

Ha pedig a fénysebesség változását veszed támpontúl, akkor rá tudol építeni egy görbült téridőt.

A quarter wave plate-et rendesen kell szamolni, ez az egyszerűsített modell így nem fog tökéletes eredményt adni.

Nem Eukleidészi térben, vagyis a görbült terekben haladó fénysugár az ott egyenesnek számító geodetikuson halad.

"Ezt a mondatot nem értem: "A fénysugarak ugyanis csak akkor görbülhetnek el, ha a fényterjedés sebessége más és más a különböző helyeken." "

Én viszont "értem" -  kisiskolás koromban hallottakra támaszkodva.

Nevezetesen: Ha a fénysugarak olyan helyeken vonulnak át vákuumban, amely helyeken a  törésmutató értéke helyről-helyre változó - úgy terjedésük irányát  legpontosabban meghatározni az általános relativitáselmélet ismeretében lehet.

" Novobátzky megjegyzését sem gondolom hogy rá lehetne húzni a "titokzatos távolhatásra", "

Novobátzky Károly szerintem megpróbálta eloszlatni azt a tévhitet,  amely szerint  a fizika nem ismer c-nél nagyobb sebességet.

Az alap ábra mostmár szinte hajszálpontos és két hiba javítva. És négy subquark ban.

ds_distance2=420

double dist2b=sqrt(sqr(0 - hole2x) + sqr(ds_distance2));

Ellenben még mindig problémás a megoldás. De nyilván helyes az út, hiszen a a Dp oldalon egy fél foton visszafele halad, akkor ismeri a másik oldali történéseket (a kialakult fázist). Márpedig ez a kulcs.

double dist2b=sqrt(sqr(ds_pos - hole2x) + sqr(ds_distance2)); 

Van még bőven apró hiba, de sorba kiesnek majd. ds_pos nem lehet ebben a sorban, ide a BBO-ra eső szélesség kell majd, ami 0,5mm.

A kisérlet a fél foton bizonyítéka.

Számomra, mert arra aztán várhatunk, hogy ezt bárki beismerje,.

Ez a világ nem úgy működik, mint Einstein korában.

"miért van interferencia."   ha csak egy résen megy át?

Közben rájöttem, hogy a fél foton az időben visszafele haladóval interferál.

Szóval nem találtam 4 félfotonos megoldást.

De mégis van. Hol? Pont itt ebben az 1006-os megoldásban.

Ugyanis lehet, hogy az időben "visszafele" induló fél foton nem számít a detektáláskor. Ebben az esetben a 4 félfoton egyenlete pont ilyen, mint ezé a kettőe.

Mit akarok kihozni?

Nos az terjesztik, hogy a kisérlet SEMMIFÉLE módszerrel nem szimulálható.

Én meg leszimuláltam a lehetetlent. Majdhogy nem pontos interferencia mintát ad a program.

Én nem akarok semmit, csak tudom merre van az igazság.

Nem, a relativitás szerint a fénysebesség mindig c, így nem azért görbülnek el a fénysugarak, mert változik a c, hanem a téridő görbülete miatt.

Szerintem meg a kettő ugyan az. De ez a megközelítés annyira nem elfogadott, hogy a wikiről még a sebesség képletét is leszedették.

Persze ettől még nem lesz igazuk.

Nem akarom azt a látszatot kelteni, hogy értem, hogy mit akarsz kihozni ebből a félfoton elméletből. Csupán van egy olyan gyanúm, hogy ezzel bizonyos kétrés kísérleteket ha meg is lehet magyarázni, akkor is problémák adódnak a háromrés, vagy többrés kísérletekkel. Innen kezdve bukta az egész. Nem?

Köszönöm!

Mit jelent az, hogy "Einstein könyve"? A spec és ált rel?

Ezt a mondatot nem értem: "A fénysugarak ugyanis csak akkor görbülhetnek el, ha a fényterjedés sebessége más és más a különböző helyeken."

Csak mert mintha nem erről szólna az áltrel, hanem pont arról, hogy elgörbülhetnek. Na persze most mit értünk elgörbülés alatt? Úgy veszem, hogy a gravitáció okozta "fényelhajlást", ami valójában egy geodetikus...

Tulajdonképpen teljesen mindegy. Viszont ami nem mindegy: ez az idézet Einsteintől nem mond semmi olyasmit, hogy a fénynél gyorsabb hatást bármilyen módon elfogadhatónak tartott volna Einstein. Csak annyit jelent, hogy nem állandó (lehet mondjuk lassabb). Novobátzky megjegyzését sem gondolom hogy rá lehetne húzni a "titokzatos távolhatásra", egész más jellegű ez a fajta c-nél nagyobb sebesség. Mert ugyebár onnan indultunk, hogy mit gondolhatott Einstein a fénysebességről, de persze a kvantumfizikai távolhatás kontextusában...

Őszintén be kell vallanom, hogy nem vagyok meggyőzve ;-)

Igen. Idézet Einstein könyve 22. fejezetéből:

* ... az általános relativitáselmélet szerint a vákuumban terjedő fény sebességének állandóságáról szóló már annyiszor említett törvény, amely egyike a speciális relativitáselmélet két alapvető feltevésének, nem tarthat igényt korlátlan érvényességre. (33) A fénysugarak ugyanis csak akkor görbülhetnek el, ha a fényterjedés sebessége más és más a különböző helyeken. ...*

Ez értelmezhető volna úgy is, hogy bár az általános relativitásban c-nél kisebb sebességű EM hullámok is megjelennek, de c továbbra is felső sebességhatárnak minősül - ám Dr. Novobátzky Károly Einstein fenti első mondatához e megjegyzést  fűzte:

* 33. Az általános relativitáselméletben, ahol bármilyen koordinátarendszert felhasználhatunk, az sem érvényes, hogy a testek nem mozoghatnak c-nél nagyobb sebességgel. Pl. a Földet használva vonatkoztatási rendszerül, azt tapasztaljuk, hogy a legtávolabbi ködök is egy nap alatt megkerülik a Földet. Ezt az óriási kört pedig csak úgy írhatják le 24 óra alatt, ha a c fénysebességnél gyorsabban
mozognak. Csak inerciarendszerben nem észlelhetünk c-nél nagyobb sebességet. *