Keresés

//t=0.0;//egyik osszetevo
//t=1.0;//masik

Erdemes a ket per jelet eltavolitva megnezni az eredeti hullamokat. Ugyanis a hullamcsomagok mindenfele trukkozes nelkul kiadjak a Lorentz-transzformaciot.

Az elemi hullam hullamfrontja egybeesik a mozgo koordinata-rendszer ter-tengelyevel, az eredo hullamcsomag mozgasi iranya pedig az ido-tengellyel.Ez pontosabban kiveheto, ha a ket sebesseg kozelebb van egymashoz.

 float v1=-c*0.2;
 float v2=-c*0.24;

A relativitas egyik alapegyenlete visszavezetheto a hullamfizikara.

"kvantummechanika oszcillátoraira kell kicserélni a klasszikus mechanikai oszcillátorokat"

Ez nem egeszen igy van. A linkelt eloadason jo osszefoglalot talalsz, de ugy tunik, meg mindig nem tudsz elegge angolul. Vagy lusta vagy vegignezni,

Nagyon erdekes, hogy sokan ugy kepzelik el ezeket a hullamokat, hogy valamilyen VALOS terbeli iranyba allnak ezek a forgo vektorok. 

Pedig nem egeszen. Legtobbszor ezek elvont tereket reprezentalnak.

Linearisan polarizalt hullamokat eloallithatunk ket egymassal szembeforgo hullambol. Ezt teszi a termeszet is, hiszen a foton spinje csak ket erteket vehet fel.

Úgy képzeld el például az elektromágneses mezőnél, hogy jó közelítésnek elfogadod a klasszikus elektrodinamika Maxwell-féle elméletét, amiben az elektromágneses hullámok terjednek. Ebben a mező minden egyes térpontja úgy viselkedik, mintha harmonikus oszcillátor lenne. Harmonikus oszcillátorok sokaságának tekinthető a mező, amik egymással összhangban rezegnek, és együtt létrehozhatnak A kvantumelektrodinamikában minden marad a régi, az egyetlen változtatás az, hogy a mezők oszcillátorait kvantálni kell, vagyis a kvantummechanika oszcillátoraira kell kicserélni a klasszikus mechanikai oszcillátorokat. A kvantummechanikai oszcillátornak diszkrét-féle időfüggetlen energiaállapota van.

http://hu.wikipedia.org/wiki/Harmonikus_oszcill%C3%A1tor

Ahányodik nívón van egy oszcillátor, annyi részecskét képzelnek a mezőnek abba a pontjába. Vagyis a mezők gerjesztett állapotait lehet részecskék sokakságaként megszemélyesíteni. De a részecskék azonossága, vagyis, hogy az azonos részecskéket nem lehet megkülönböztetni, pont azt jelenti, hogy ez a szemlélet igazából sántít. A valóság a mező, és gerjesztettsége. És igen, a hullámok.

A komplex hullámok nem egyebek, mint a cirkulárisan poláros hullámok. Ez, ha egyik irányba csavarodik, akkor exp(i*omega*t), míg ha a másik irányba csavaródik, akkor exp(-i*omega*t) http://www.enzim.hu/~szia/cddemo/demo13.htm

a lineárisan poláros hullámok pedig a szinuszos vagy koszinuszos hullámok

http://www.enzim.hu/~szia/cddemo/demo12.htm

Nos, beleolvastam.

Szep ez a fizikus nyelv, de felesleges kodositeni.

" A hullámfüggvény részecskekeltő és eltüntető operátorok lineáris kombinációjává vált, s ezek az operátorok a részecskeszám-téren (Fok-tér) hatottak. "

Lecture 3 | New Revolutions in Particle Physics: Basic Concepts

video 25 perc

Ezek az operatorok megfelelnek a klasszikus fourier coefficients-eknek, azaz a Fourier-egyutthatoknak.

Ismet csak ezek a franya hullamok.

Egy dolgot fontos eszben tartani.

Lehet hogy ezek a komplex hullamok tenyleg nem leteznek, csak a mi leiro elmeletunkben,

De ez itt lenyegtelen. Mert a leiro elmelet szerint a teridoben felrajzolva ezeket a hullamokat, az altalam levezetett eredmenyt adjak.

Tehat a diffrakcios magyarazat helyessege nem fugg attol, hogy ezek a hullamok valosak vagy nem.

Bar tovabra sem tudom elkepzelni olyan diffrakciot-interfenciat-modulaciot-hullamhosszt-frekvenciat, ami egy valos hullamtol fuggetlenul jon letre.

A diffrakcional jol kiveheto amirol mar irtam. Az egeret jobbra-balra mozgatva mindig egy diffrakcios irany erosodik ki.

Az elektron valoszinusegi amplitudoja ezen a vilagvonalon lesz nagy, itt lehet elektront detektalni. Ez az erosodes mindig adott "kvantumokban" ugral arrebb. Ez a Bragg diffrakcio termeszetebol ered.

Ez egyfajta energia kvantalas.

Az energia-kvantaltsaga nem csak egyfelekepp jelenik meg. Ha egy hullamot zart palyara kenyszerintunk, akkor ott is kvantalt energiat kapunk. Ennek levezetese a videon az 49. perctol lathato.



Rovid osszefoglalo.

Van egy L hosszu drot, aminek a vege es az eleje ossze van kotve.

Egy ebben mozgo reszecskenek csak L/N hullamhossza lehet, hiszen nincs olyan hullam, amiben egy meredek tores van.

L=r2pi

lambda=L/N

Az ehhez rendelheto impulzus:

P=h/lambda=Nh/L

P=Nh/(r2pi)

es a http://hu.wikipedia.org/wiki/Perd%C3%BClet perdulet /szogmomentum, impulzusmomentum/

P(angular)=mvr = Pr

P(angular)=rNh/(r2pi) = N*hbar , vagyis csak a hbar allando egesz szamu tobbszorose lehet.

hbar=h/(2pi)

Mindket esetben az ok a hullam, es annak jol ismert tulajdonsaga, viselkedese.

Hogyan veszi fel a QM a fazissebesseget? A kek nyil szerint. 1 masodperc telik el, a piros hullamfront LATSZOLAG megtett egy hatalmas tavolsagot, amibol fenysebessegnel nagyobb sebesseget lehet szamolni.

Csakhogy a hullamfront nem a piros vilagvonal mententen terjed, hiszen az MAGA a teridobeli hullamfront. A teridobeli terjedes a zold nyilak szerint tortenik.

Osszefoglalom a mondandom.

TERBEN a hullamfront a kek nyil szerint terjed. Ha a fazissebesseg merheto lenne, ezt a terjedesi iranyt kapnank, / a ter most az X tengely, az Y az ido./

De a teridoben a hullamfront a fekete nyil iranyaba haladna, ha mozogna. Ezt igy szoktuk meg a kozonseges hullamoknal, ezzel igy helyes, igy KELL szamolni a diffrakciot.

Egy hullam vetuletevel, mint amilyen a kvantummechanikai anyaghullam, ezt nem lehet megtenni. Annak ugy semmi ertelme.

Mivel nyomat sem latom semmifele cafolatnak, tovabbra is allitom, hogy az elektromagneses kolcsonhatas egyszeru Bragg-diffrakcio.

50 anyaghullambol allo hullamcsomag mozgasa teridoben:

#ifdef GL_ES
precision highp float;
#endif

uniform vec2 resolution;
uniform float time;
uniform vec4 mouse;

#define pi 3.1415926
float radian=pi/180.0;



void main(void)
{
 vec2 mouse2=mouse.xy/resolution.xy;
 vec3 screen=vec3(gl_FragCoord.xy/resolution.xy,0.0);


 float c=1.0,m=1.0,h=1.0;
 float v1=-c*0.2;//0 -> 1
 float v2=-c*0.4;//v1 -> 1
 float b1=1.0/sqrt(1.0-v1*v1/(c*c));    float l1=h/(m*b1*v1);
 float b2=1.0/sqrt(1.0-v2*v2/(c*c));    float l2=h/(m*b2*v2);

 float vf1=c*c/v1;
 float vf2=c*c/v2;
 float a1=atan(v1/c);
 float a2=atan(v2/c);
 vec3 p1=vec3(sin(a1),cos(a1),0.0);
 vec3 p2=vec3(sin(a2),cos(a2),0.0);
 l1*=sin(a1);
 l2*=sin(a2);
    



 float amp=0.0;
 float skala=1000.0;//nagyitas=10  normal=1000
    
 float n=50.0;
 for(int i=0;i<50;i++)//n!  hullamcsomag
 {
   float t=float(i)/n;
//t=0.0;//egyik osszetevo
//t=1.0;//masik

   vec3 p3=p1+(p2-p1)*t;//linear interpolation
   float hhossz=l1+(l2-l1)*t;
   hhossz/=skala;
   float k=pi*2.0/hhossz;

   float tav=dot(screen,p3);        
   amp+=sin(tav*k -time);//a hullam nem mozog a teridoben, csak igy latvanyosabb!
 }

 amp/=n;

 if(amp<0.0) gl_FragColor=vec4(-amp,0,0,1);
 else        gl_FragColor=vec4(0,amp,0,1);
}


    

Mostmar ertheto, hogyan tud menni fenysebesseg felett az anyaghullam.

Sehogy.

Az a hullamfront, ami a kep jobb oldalan eleri az x tengelyt, nem az origobol indult, hanem a piros nyil altal jelzett iranybol.

A teridoben a hullam c-nel kisebb sebesseggel "terjedt" . /nem mozog!/

Itt nem a v a sebesseg, hanem az x/t vagyis az x, mivel t=1;

Hogyan kell kiszamolni az anyaghullam fazissebesseget?

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

Matter wave phase:

v(fazis)=c^2/v

A Mai fizika sorozatban ez all:

    w=c*sqrt(k*k+m*m*c*c/(h_bar*h_bar));
    v2=w/k;

Ha igazam volt, akkor igy:

    b=atan(v/c);
    v2=c*cos(b)/sin(b);

Miert? Mert idoben t=1 masodperc alatt s=t*c "utat" tesz meg MINDEN.

Igy a sebesseg az, amekkora utat tett meg terben / x tengely/ a hullamfront alja.

cosfi=v/tc -> v=tc cosfi

sinfi=v/x -> x=v/sinfi = tc cosfi/sinfi es t=1

vagy egyszerubben : tanfi=tc/x  ->  x=c/tanfi

A program kimenete:

4.213483146067e+08
4.213483146067e+08
4.213483146067e+08
4.213483146067e+08

Termeszetesen igazam volt. S hullam pontosan ugy ALL a teridoben, ahogy leirtam. Csak epp ott nem mozog. xD

#include <stdio.h>
#include <stdlib.h>
#include <math.h>


int main()
{
    double h=6.626e-34,m=9.1e-31,c=3e8,e=1.6e-19,b,v,l1,m2,E,E0,E2,t2,v2,f,l,h_bar,w,k;
    
    v=0.712*c;
    v2=c*c/v;
    printf("%.12e n",v2);

    b=atan(v/c);
    v2=c*cos(b)/sin(b);

//    v2=c/tan(b);//vagy

    printf("%.12e n",v2);

    b=1.0/sqrt(1.0-v*v/(c*c));
    f=m*c*c*b/h;
    l=h/(m*v*b);    
    v2=l*f;
    printf("%.12e n",v2);


    b=1.0/sqrt(1.0-v*v/(c*c));
    l=h/(m*v*b);    
    k=2.0*M_PI/l;
    h_bar=h/(2.0*M_PI);
    w=c*sqrt(k*k+m*m*c*c/(h_bar*h_bar));
    v2=w/k;
    printf("%.12e n",v2);
    
    return 0;
}

De nem ez az ok amiert visszajottem.

A teridoben mozgo hullam haladasi iranya sokakat osszezavar. Nem ertik, hogy merre megy ez a hullam.

Sokat egyszeruen kijelentik, hogy ugy hulyeseg az egesz ahogy van, mert a hullamfront nem arra mozog.

Nos en nem tevedtem, sot furcsamod az sem, aki azt allitja, hogy a hullam frontjanak mozgasi iranya nem az amit megadtam.

Hogyan lehetseges ez?

A kulcsszo :fogalomzavar.

Az elso problema, hogy en is sokszor irtam, hogy a teridoben mozgo hullam haladasi iranyat szamolom, mikozben a teridoben levo hullam nem mozog. En ezzel tisztaban vagyok, ez csak egy rossz  szohasznalat volt.

A masik az, hogy a hullam terben mozog, es ott ennek a mozgasi iranya a hullamfront mozgasanak az iranya. Ennek hullamfrontnak a sebessege a kvantummechanikaban az anyaghullam fazissebessege. Ezt kozelebbrol is megnezem, hogy kitisztuljon minden reszlet.

Akkor mi az amit en szamoltam?

A teridoben, mint latszani fog, a hullam pont olyan hullamfrontokat rajzol ki, mintha egy kozonseges 2 dimenzios hullam lenne. Ekkor a terido 1 ter es 1 idodimenzios. De a hullamfront nem mozog, hanem a kozonseges 2 dimenzios hullamnak egy idometszete, egy pillanatnyi allapotahoz hasonlit.

Az altalam szamolt irany, az atan(v/c), ennek a megfagyott hullam hullamfronjanak az iranya. Tehat az az irany, amerre ez a hullam haladna a teridoben, ha mozogna.

Ezzel az irannyal KELL szamolni, maskulonben ertelmetlenne valik az egesz. Mint meg fogom mutatni, az anyaghullam terbeli mozgasa lenyegtelen, csak egy metszete ennek a hullamnak. Ezert is kapunk az kvantummechanikai fazissebessegre fenysebessegnel nagyobb sebessegeket.

Akkor szamoljunk.

A forditas button a szovegdoboz feletti ikon /compile/ vagy nyomni kell egy alt-entert.

A render kepre rahuzva az egeret es folyamatosan nyomva tartva az egerbuttont, lehet elforgatni a racsot vizszintes egermozgassal, vagy a hullamhosszt valtoztatni fuggoleges egermozgassal.

A program atirhato, manipulalhatjuk kedvunk szerint.

Lehet kiserletezni.

Az alabbi sort #if 1 atirva #if 0  -ra nem a hullamhossz valtozik, hanem a racstavolsag.

Mint lentebb irva vagyon, a Bragg-diffrakcional a toresi szog valtozasa es az elektron vilagvonalanak elhajlasa hasonlo torvenyeket kovet.

En vok ironman  lol, nem mindegy?

Szoval, vissza a fizikahoz. Elerkezett az ido, amikor barki irhat shadert egy egyszeru browserben, mint pl a firefox 4.

Ez majd sokmindenre lehet hasznalni, tobbek kozt a fizika oktatasban.

Kezdetnek alljon itt a Bragg-diffrakciot bemutato shader.

#ifdef GL_ES
precision highp float;
#endif

uniform vec2 resolution;
uniform float time;
uniform vec4 mouse;

#define pi 3.1415926
float radian=pi/180.0;


void main(void)
{
  vec2 mouse2=mouse.xy/resolution.xy;
  vec3 screen=vec3(gl_FragCoord.xy/resolution.xy,0.0);


  float amp=0.0;
#if 1  
  float hhossz=0.2+mouse2.y*7.0;//eger mozog fuggolegesen, hullamhossz valtozil
  float d=10.0;
#else  
  float hhossz=0.7;
  float d=10.0+mouse2.y*17.0;//eger mozog fuggolegesen, racstavolsag valtozil
#endif
  float szog=(mouse2.x*180.0)*radian;//eger mozog vizszinesen
  vec3 xirany=vec3(sin(szog),cos(szog),0.0);//racs x
  vec3 yirany=vec3(xirany.y,-xirany.x,0.0);//y tengelye

float skala=20000.0;//screen meret 0-1, ehhez kell allitani mindent
hhossz/=skala;
d/=skala;
  float k=pi*2.0/hhossz;

  for(int y=-10;y<11;y++)
  for(int x=-10;x<11;x++)
  {
    vec3 racs=vec3(0.5,0.5,0.0)+
       xirany*float(x)*d+
       yirany*float(y)*d*0.3;
    float tav=racs.y;//hullam y iranyban mozog!

    tav+=length(screen-racs);//tavolsag a racstol a keppontig
    amp+=sin(tav*k);
  }
  amp*=4.0;//vilagosabb
  amp/=(20.0*20.0);

  if(amp<0.0) gl_FragColor=vec4(-amp,0,0,1);
  else        gl_FragColor=vec4(0,amp,0,1);
}


//http://www.iquilezles.org/apps/shadertoy/

Ha minden jol megy, akkor csak be kell masolni az alabbi link szovegdobozaba a programot, raklikkelni a forditas gombra, es mar fut is a shader.

Te meg ki vagy???

Fizikus vagy-é?

Ha igen, akkor erről mi a véleményed???

Ha nem, akkor ehhez mit mernél hozzátenni??? :)

Ami érdekes a szimulációban, hogy a polarizációs iránynak semmi köze a hullámhoz. A kettő független tulajdonsága a fotonnak. A két foton polarizációja egyező, és az anyaghullám indulási fázisa egyenlő. Ez a két feltétel kell csak, hogy az eredmény helyes legyen.

Tévedtem. Inkább csak mint leírási mód marad, hiszen akkor lenne értelme időbeli visszahatásról beszélni, ha az idler intenzitása elérné a pumpáló sugárét. Ekkor minden foton két fotonra konvertálódna. Ott nincs magyarázat a sugár kis intenzitására, míg a lebegés pontos magyarázatot ad arra, miért csökken az intenzitás.

Ameddig nincs nagy intenzitású idler sugár forrás, addig nincs értelme időbeli visszahatásról beszélni.

http://www.kfki.hu/fszemle/archivum/fsz0610/janszky0610.html

A fény nemklasszikus állapotai

A nemklasszikus tulajdonság kialakulásának oka a két állapot közötti kvantuminterferencia.

A fény egy hullám, és csak annyira részecske, mint egy hullámcsomag. Semennyire.

Távolhatás törölhető, de az időbeli visszahatás, mint lehetőség és mint leírási mód, marad az egyértelmű kisérleti cáfolatig.

De szerintem olyan nem lesz. Nem lehet olyat megcáfolni, ami mérhetetlen.

Marad az ismert borotva, bár annak alkalmazása szerintem tudománytalan. De ez is csak egy magánvélemény,

Szomorúan közlöm, semmiféle  távolhatást nem kell feltételezni, hanem van egy közös rejtett paraméter, ami a modulációt okozó két hullám fázisa, a fazis1.

Az a 15.8 százalék valósnak tünik.

A talált értékek  10 és 25 százalék közt szórnak.

google bbo idler intensity

http://www.iitk.ac.in/ee/faculty/pkumar/pubs/acf_pradeep.pdf


http://adsabs.harvard.edu/abs/2001SPIE.4350..136H
http://link.aip.org/link/?PSISDG/4350/136/1
In the 9 mm BBO crystal at pump intensity approximately 68 MW.cm and input idler
intensity approximately 18 MW.cm the efficiency of energy extraction in the

Ez a megoldás csak akkor igaz, ha a kevert hullámú résznél hatod annyi foton mérhető.  1/6.3

Érdekes, soha nem hittem az időbeli visszahatásban.

Mostmár akár el is lehetne dobni az a megoldást, hiszen itt egy klasszikus helyette.

Most mégis úgy gondolom, Wheelernek és Feynmannak volt igaza. Hogy miért?

Maradjanak titkok is a világban.

Az EPR-probléma egyik, modulációs megoldása:

A polarizátorok a Malus-törvény szerint engedik át a fényt, de jelen van egy moduláció, amit két közeli frekvenciájú hullám kelt. Ennek az burkolója szorzódik a Malus értékkel.

 valoszinuseg=sqr(cos(polarizator1-foton_polarizacio)*modamp1);

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

A modamp a két forgó hullámvektor modulációjának a burkolója.

Az eredmény 22 fokra 2.97, ami bőven jó. Ennél a szögértéknél sértik a Bell egyenlőtlenségeket a kisérletek.

És a moduláció is. A két oldal független, tehát klasszikus eloszlást számol a program.

tesztszog: 0, modulacio: 1.84117, kvantumfizika: 2.00002
tesztszog: 2, modulacio: 1.86134, kvantumfizika: 2.01533
tesztszog: 4, modulacio: 1.89647, kvantumfizika: 2.05798
tesztszog: 6, modulacio: 2.02935, kvantumfizika: 2.12618
tesztszog: 8, modulacio: 2.1324, kvantumfizika: 2.21184
tesztszog: 10, modulacio: 2.33257, kvantumfizika: 2.31344
tesztszog: 12, modulacio: 2.57762, kvantumfizika: 2.43092
tesztszog: 14, modulacio: 2.80614, kvantumfizika: 2.54366
tesztszog: 16, modulacio: 2.94834, kvantumfizika: 2.64659
tesztszog: 18, modulacio: 3.07892, kvantumfizika: 2.73725
tesztszog: 20, modulacio: 3.04488, kvantumfizika: 2.79418
tesztszog: 22, modulacio: 2.97815, kvantumfizika: 2.82606
tesztszog: 24, modulacio: 2.7958, kvantumfizika: 2.81676
tesztszog: 26, modulacio: 2.69214, kvantumfizika: 2.76263
tesztszog: 28, modulacio: 2.47125, kvantumfizika: 2.65808
tesztszog: 30, modulacio: 2.25672, kvantumfizika: 2.50501
tesztszog: 32, modulacio: 1.91933, kvantumfizika: 2.29487
tesztszog: 34, modulacio: 1.6886, kvantumfizika: 2.03643
tesztszog: 36, modulacio: 1.33774, kvantumfizika: 1.73813
tesztszog: 38, modulacio: 0.912208, kvantumfizika: 1.3984

#include <iostream>
#include <math.h>

using namespace std;



double radian=M_PI/180.0;
int szamlalo[16];

double sqr(double n) {return n*n;}
inline double veletlen() {return fmod((double)rand()/65500.0,1.0);}



double Ef(int s1,int s2,int s3,int s4)
{
double szamlalo_base2=(szamlalo[s1]+szamlalo[s2]+szamlalo[s3]+szamlalo[s4]);
if(szamlalo_base2==0) return 0;

return (double)(szamlalo[s1]+szamlalo[s2]-szamlalo[s3]-szamlalo[s4])/szamlalo_base2;
}

int csatorna_a=0;
int csatorna_a_=0;
int csatorna_a2=0;
int csatorna_a2_=0;
int csatorna_b=0;
int csatorna_b_=0;
int csatorna_b2=0;
int csatorna_b2_=0;

void ellenorzes_szamlalo()
{
if(csatorna_a) if(csatorna_b) szamlalo[0]++; //++
if(csatorna_a_) if(csatorna_b_) szamlalo[1]++; //--
if(csatorna_a) if(csatorna_b_) szamlalo[2]++; //+-
if(csatorna_a_) if(csatorna_b) szamlalo[3]++; //-+

if(csatorna_a) if(csatorna_b2) szamlalo[4]++; //++
if(csatorna_a_) if(csatorna_b2_) szamlalo[5]++; //--
if(csatorna_a) if(csatorna_b2_) szamlalo[6]++; //+-
if(csatorna_a_) if(csatorna_b2) szamlalo[7]++; //-+

if(csatorna_a2) if(csatorna_b) szamlalo[8]++; //++
if(csatorna_a2_) if(csatorna_b_) szamlalo[9]++; //--
if(csatorna_a2) if(csatorna_b_) szamlalo[10]++; //+-
if(csatorna_a2_) if(csatorna_b) szamlalo[11]++; //-+

if(csatorna_a2) if(csatorna_b2) szamlalo[12]++; //++
if(csatorna_a2_) if(csatorna_b2_) szamlalo[13]++; //--
if(csatorna_a2) if(csatorna_b2_) szamlalo[14]++; //+-
if(csatorna_a2_)if(csatorna_b2) szamlalo[15]++; //-+
}



double S2modulacio(double a,double b,double a2,double b2,int op)
{
    int k;

    for(k=0;k<16;k++) szamlalo[k]=0;




    for(k=0;k<500000;k++)//meres
    {
        double foton_polarizacio=veletlen()*M_PI*2;
        double foton_polarizacio2=foton_polarizacio;//veletlen()*M_PI*2;
        double valoszinuseg, valoszinuseg2,polarizator1,polarizator2;
        csatorna_a=0;
        csatorna_a_=0;
        csatorna_a2=0;
        csatorna_a2_=0;
        csatorna_b=0;
        csatorna_b_=0;
        csatorna_b2=0;
        csatorna_b2_=0;

        int o1=0,o2=0;
        polarizator1=a;if(veletlen()<0.5) {polarizator1=a2;o1=1;}
        polarizator2=b;if(veletlen()<0.5) {polarizator2=b2;o2=1;}
       


        double l1=680e-9;
        double l2=725e-9;
        double k1=2.0*M_PI/l1;
        double k2=2.0*M_PI/l2;

        double amp1x,amp1y,amp2x,amp2y,
            modamp1,modamp2,
            tav=10.76574,tav2=11.23;
        double fazis1=veletlen()*M_PI*2;
        
        amp1x = sin(fazis1+tav*k1)*0.5;
        amp1y = cos(fazis1+tav*k1)*0.5;
        amp1x += sin(fazis1+tav*k2)*0.5;
        amp1y += cos(fazis1+tav*k2)*0.5;
        modamp1=amp1x*sin(polarizator1) + amp1y*cos(polarizator1);        
        modamp1*=modamp1;
        
        amp2x = sin(fazis1+tav2*k1)*0.5;
        amp2y = cos(fazis1+tav2*k1)*0.5;
        amp2x += sin(fazis1+tav2*k2)*0.5;
        amp2y += cos(fazis1+tav2*k2)*0.5;
        modamp2=amp2x*sin(polarizator2) + amp2y*cos(polarizator2);        
        modamp2*=modamp2;


        valoszinuseg=sqr(cos(polarizator1-foton_polarizacio)*modamp1);
   
        if(valoszinuseg>veletlen())
        {
                if(o1==0) csatorna_a=1;
                else      csatorna_a2=1;
        }
        else
         {
             polarizator1+=M_PI/2;
             
        modamp1=amp1x*sin(polarizator1) + amp1y*cos(polarizator1);        
        modamp1*=modamp1;
            valoszinuseg=sqr(cos(polarizator1-foton_polarizacio)*modamp1);
           
            if(valoszinuseg>veletlen())
             {
                if(o1==0) csatorna_a_=1;
                else      csatorna_a2_=1;
            }
        }
   
        valoszinuseg=sqr(cos(polarizator2-foton_polarizacio)*modamp2);
       
        if(valoszinuseg>veletlen())
         {
                if(o2==0) csatorna_b=1;
                else      csatorna_b2=1;
        }
        else
         {
             polarizator2+=M_PI/2;
             
        modamp2=amp2x*sin(polarizator2) + amp2y*cos(polarizator2);        
        modamp2*=modamp2;
            valoszinuseg=sqr(cos(polarizator2-foton_polarizacio)*modamp2);
           
            if(valoszinuseg>veletlen())
             {
                if(o2==0) csatorna_b_=1;
                else      csatorna_b2_=1;
            }
        }
        ellenorzes_szamlalo();
    }
    //ab -ab2 a2b a2b2
    double N=0.0;

    N=Ef(0,1,2,3);
    N-=Ef(4,5,6,7);
    N+=Ef(8,9,10,11);
    N+=Ef(12,13,14,15);
   
   
    return N;
}




double S2kvantumfizika(double a,double b,double a2,double b2,int op)
{
    int k;

    for(k=0;k<16;k++) szamlalo[k]=0;




    for(k=0;k<500000;k++)
    {
        double foton_polarizacio=veletlen()*M_PI*2;
        double foton_polarizacio2=foton_polarizacio;
        double valoszinuseg, polarizator1,polarizator2;
        csatorna_a=0;
        csatorna_a_=0;
        csatorna_a2=0;
        csatorna_a2_=0;
        csatorna_b=0;
        csatorna_b_=0;
        csatorna_b2=0;
        csatorna_b2_=0;

        int o1=0,o2=0;
        polarizator1=a;if(veletlen()<0.5) {polarizator1=a2;o1=1;}
        polarizator2=b;if(veletlen()<0.5) {polarizator2=b2;o2=1;}

       
       
            valoszinuseg=sqr(cos(polarizator1-foton_polarizacio));
            if(valoszinuseg>veletlen() )
             {
                    if(o1==0) csatorna_a=1;
                    else      csatorna_a2=1;

                    foton_polarizacio2=polarizator1;//spooky action at distance
            }
            else
             {
                 polarizator1+=M_PI/2;
                
                {
                    if(o1==0) csatorna_a_=1;
                    else      csatorna_a2_=1;

                    foton_polarizacio2=polarizator1;//spooky action at distance
                }
            }
       
       
       
            valoszinuseg=sqr(cos(polarizator2-foton_polarizacio2));
            if(valoszinuseg>veletlen() )
             {
                    if(o2==0) csatorna_b=1;
                    else      csatorna_b2=1;
            }
            else
             {
                {
                    if(o2==0) csatorna_b_=1;
                    else      csatorna_b2_=1;
                }
            }
       
        ellenorzes_szamlalo();
    }
    //ab -ab2 a2b a2b2
    double N=0.0;

    N=Ef(0,1,2,3);
    N-=Ef(4,5,6,7);
    N+=Ef(8,9,10,11);
    N+=Ef(12,13,14,15);


    return N;
}



int main()
{
    for(int i=0;i<40;i+=2)
    {
    double S=0.0,tesztszog=i,a,a2,b,b2;
   
    a=0.0;
    b=tesztszog;
    a2=tesztszog*2.0;
    b2=tesztszog*3.0;
   
    a*=radian;
    b*=radian;
    a2*=radian;
    b2*=radian;


    cout << "tesztszog:" << ' ' << i << ", ";

    S=S2modulacio(a,b,a2,b2 ,0);
    cout << "modulacio:" << ' ' << S << ", ";

    S=S2kvantumfizika(a,b,a2,b2 ,0);
    cout << "kvantumfizika:" << ' ' << S << endl;
}

}

 

 

A forgó vektoroknak van egy különleges tulajdonságuk.

A két közeli frekvenciájú hullámot összegezve az eredő hullám hullámhossza a moduláció hullámhossza lesz.

Ez az eredő a sárga görbe, természetesen négyzetreemelés után kapunk ilyen görbét. A görbe magassága a forgó vektor nagyságát mutatja. Két csúcspont távolsága pedig a moduláció hullámhossza. A kvantumfizika modulációkkal számol, csak rejtve.

A piros a forgó hullám egyik metszete. A forgó hullámvektor nagysága folyamatosan nő, ahogy a sárga görbe emelkedik. Nincs olyan ugrálás, mint a metszetnél, avagy egy normál hullámnál.

A cikkben elhangzanak olyan fogalmak, hogy klasszikus és kvantumos számítási mód.

De tévedés azt hinni, hogy a kvantumos számítási mód nem klasszikus hullámokkal számol.

A sárga görbe "klasszikus"  hullámokkal számol, és nem ad jó eredményt, ez tény.

            amplitudo1=cos(fazis1+tav*k1) + cos(fazis2+tav*k2)
            amplitudo2=cos(fazis1+(tav+dt)*k1) + cos(fazis2+(tav+dt)*k2)


Csakhogy a piros görbe IS klasszikus hullámokkal let felírva, csak ezek a hullámok forognak. Klasszikus forgó hullámok a kvantumszámításokkal egyező eredményt adnak. Ez nem is csoda,, hiszen a kvantumfizikai leírás is forgó hullámokat használ, csak komplex számok mögé rejti ezeket.

Attól még klasszikus egy hullám, hogy forog. Csak ritkán tapasztalható ilyen a hétköznapi életben.

            amplitudo1.x=cos(fazis1+tav*k1)
            amplitudo1.y=cos(fazis2+tav*k2)
            
            amplitudo2.x=cos(fazis1+(tav+dt)*k1)
            amplitudo2.y=cos(fazis2+(tav+dt)*k2)