S'il y a une onde dans un espace unidimensionnel, alors il y a un champ dans cet espace, et donc une variable d'état U qui indique à chaque point `x` et à chaque instant `t`, un réel appelé valeur du champ que l'on note `U` ou explicitement `Ucolor(#006090)("("x,t")")`. Et on note parfois l'expression sur quoi s'applique l'application qui est à la fois une variable d'état, dans une couleur légèrement plus verte pour faire la distinction avec le produit. Nous avons donc une variable d'état `U` fonction de la position `x` et du temps `t`, ce qui se déclare par le neurone suivant :
`U"←"(x,t)`
L'onde est décrite par la fonction `(x,t)|->U(x,t)`. L'équation locale à laquelle satisfait `U` est assez simple à retrouver car il n'y en a pas beaucoup capablent de générer une propagation d'onde linéaire aussi simple. L'équation locale de l'onde `U` est l'équation différentielle partielle linéaire d'ordre 2, à coefficients constants, suivante :
`(del^2U)/(delx^2) = 1/c^2(del^2U)/(delt^2)`
où `c` est la vitesse de propagation de l'onde dans l'espace. Le système est déterminé par cette équation locale et par les conditions initiales constituées des valeurs du champ `U` à l'instant `0` en chaque point `x`, et des valeurs de sa dérivée partielle selon `t` que l'on note `dotU`, à l'instant `0` et en chaque point `x`. On remarque que la connaissance du champ `U` à un instant donné dans l'espace ne suffit pas, qu'il faut adjoindre la connaissance d'un autre champ `dotU` au même instant dans l'espace pour déterminer l'évolution du système, ces deux données initiales étant libres. Cela découle du fait que l'équation locale est une équation différentielle linéaire d'ordre 2. Nous avons par définition :
`dotU=(delU)/(delt)`
`ddotU=(del^2U)/(delt^2)`
L'équation locale est linéaire homogène, c'est à dire que si un champ `U` et un champ `V` les satisfont, alors le champ `U+V` les satisfait encore, et toute combinaison linéaire de `U` et de `V` les satisferont aussi. On peut donc ajouter les ondes entres-elles pour former d'autres ondes qui satisferont les mêmes équations locales. Ce principe de superposition nous permet de décomposer l'onde en une sommation d'ondes élémentaires. Et, contrairement au cas de dimension zéro d'espace, l'équation local de l'onde sur un espace unidimensionnel permet de définir des signaux riches contenant tout un spectre de fréquence.
Les dérivées partielles apparaissent lorsque le système de coordonnées possède plusieurs coordonnées ce qui est le cas ici avec les coordonnées de temps `t` et d'espace `x`.
Le calcul différentiel utilise le concept d'élément différentiel, qui est une variation infiniment petite, et qui au premier ordre, dévoile l'aspect linéaire local des fonctions dérivables, c'est à dire leur tangente. C'est pourquoi les opérateurs de dérivée (de dérivée totale et de dérivée partielle) sont étudiés en même temps que les opérateurs linéaires que sont les matrices et que le calcul matriciel. Ces opérateurs différentiels servent a établir les équations locales d'un champ `U` supposé indéfiniment dérivable.
Les équations locales s'appliquent à l'élément différentiel d'espace-temps `dxdt` positionné au point `(x,t)`, et s'appliqueront à tout les points `(x,t)` de l'espace-temps. Elles décrivent le comportement local du champ `U`, qui est un comportement linéaire en `x` et `t`.
Les opérateurs de dérivée partielle selon chaque axe sont notés ainsi :
`(del)/(delx), (del)/(delt)`
Ils calculent la pente selon chaque axe. `delU"/"delx` désigne la pente de `U` lorsque seul `x` varie c'est à dire lorsque `dt"="0`, et `delU"/"delt` désigne la pente de `U` lorsque seul `t` varie c'est à dire lorsque `dx"="0`. Comme par hypothèse le champ est dérivable, c'est à dire localement linéaire, nous avons :
`dU = (del U)/(delx)dx + (del U)/(delt)dt`
L'élément différentiel `dU` tient compte de toutes les évolutions c'est pourquoi il est dit total (et non partiel) et est noté à l'aide d'un `d` droit. On l'appelle la différentielle totale `dU`. Et par définition nous avons :
`Ucolor(#006090)("("x"+"dx,t"+"dt")") = U + dU`
Cela nous permet d'écrire le champ au point `(x"+"dx,t"+"dt)` comme suit :
`Ucolor(#006090)("("x"+"dx,t"+"dt")") = U + (del U)/(delx)dx + (del U)/(delt)dt`
Le champ `U`, s'il ne précise pas le point où il est mesuré, est mesuré en sa position par défaut `(x,t)`, autrement dit :
`U = Ucolor(#006090)("("x,t")")`
`dU = dUcolor(#006090)("("x,t")")`
`d^2U = d^2Ucolor(#006090)("("x,t")")`
`...`
Étant donné un champ scalaire quelconque `U`. L'opérateur de dérivée partielle selon chaque axe est défini comme suit :
`(del)/(delx)U = (Ucolor(#006090)("("x"+"dx,t")")-Ucolor(#006090)("("x,t")"))/dx`
`(del)/(delt)U = (Ucolor(#006090)("("x,t"+"dt")")-Ucolor(#006090)("("x,t")"))/dx`
Et les deux notations suivantes sont permisent :
`(del)/(delx)U = (delU )/(delx)`
L'élément différentiel partiel `delU` n'a de sens que relativement à une variation infinitésimale d'une coordonnée, c'est pourquoi il n'existe jamais seul mais toujours divisé par la variation inifinitésimale de la coordonnée à laquelle il est lié, les autres coordonnées étant posées de variation infinitésimale nulle. Parcontre l'élément différentiel `dU` représente une variation infinitésimale libre et peut donc être évoqué seul. Néanmoins le concept d'élément différentiel partiel existe bien, et on adopte une notation spécifique pour pouvoir le désigné en mettant en indice du `del` la coordonnée à la quelle il est lié. Les éléments différentiels partiels se note donc comme suit :
`del_x U = (delU)/(delx)dx`
`del_t U = (delU)/(delt)dt`
Et nous avons :
`dU = del_x U +del_tU`
La dérivée partielle par rapport au temps `t` constitue une variable d'état, nommée `dotU = del U"/"del t`, et constitue un champ, et la position par défaut où il est mesuré, est le point `(x,t)`. C'est pourquoi les neuf écritures suivantes sont valables :
`(del U)/(delt) = (del Ucolor(#006090)("("x,t")"))/(delt) = (del U)/(delt)color(#006090)("("x,t")") = del/(del t) U =del/(del t) Ucolor(#006090)("("x,t")") = del_t U= del_t Ucolor(#006090)("("x,t")")=dotU = dotUcolor(#006090)("("x,t")")`
A partir de ces deux opérateurs de base que sont les opérateurs de dérivées partielles `del"/"delx` et `del"/"delt` nous pouvons définir d'autres opérateurs agissant sur les fonctions analytiques de `bbbR^2 "→" bbbR` :
Les vecteurs sont notés avec une flèche tandis que leurs composantes sont notées avec un indice. Ainsi considérons un vecteur `vecV` quelconque de dimension `2`. Nous avons le lien entre le vecteur et ses composantes qui s'écrit ainsi :
`vecV = ((V_1),(V_2))`
On regroupe les coordonnées `x` et `t` en un vecteur `vecs`, ce qui se déclare par le neurone lié suivant :
`vecs = ((x),(t))`
Le vecteur `vecs` représente le vecteur position d'espace-temps, et le vecteur `vec(ds)` représente un élément différentiel d'espace-temps :
`vecs = ((x),(t))` `vec(ds) = ((dx),(dt))`
On donne un second système de coordonnée au vecteur `U` ce qui se déclare par le neurone lié suivant :
`U = Ucolor(#006090)("("s_1,s_2")")`
On utilise les mêmes parenthèses d'appel car il n'y a pas de confusion possible entre les systèmes de coordonnées `(x,t)` et `(vecs)`. Le type, couple de scalaire ou vecteur, permet de déterminer quel système de coordonnée intervient dans l'appel. C'est un mécanisme que l'on retrouve dans de nombreux langage de programmation informatique. Un même symbole de fonction peut être utilisé pour définir plusieurs fonctions selon le type des arguments de l'appel. Après ces déclarations, nous avons bien `Ucolor(#006090)((vecs)) = Ucolor(#006090)("("x,t")")`.
L'opérateur de dérivée totale se note comme suit :
`d/(dvecs)`
La dérivée totale se note également par un guillemet simple `'` mis en suffixe, et constitue une matrice (et dans ce cas, une matrice ligne) correspondant à une fonction linéaire dans l'espace vectoriel.
`U' = (dU)/(dvecs)`
La coordonnée étant unique `vecs`, la dérivée est bien totale. Les éléments différentiels entrant en ligne de compte sont totaux et écrit à l'aide d'un `d` droit. Ils tiennents compte de toutes les évolutions c'est pourquoi ils ne sont pas partiels mais totaux. La différentielle totale `dU` se réécrit sous la forme d'un produit matriciel :
`dU = U'dvecs`
Reconsidérons l'expression de la différentielle totale `dU` vu précédement, et nous permettant d'écrire le champ au point `(x"+"dx,t"+"dt)` :
`Ucolor(#006090)("("x"+"dx,t"+"dt")") = U + (del U)/(delx)dx + (del U)/(delt)dt`
Cette expression se met sous forme matricielle comme suit :
`Ucolor(#006090)("("x"+"dx,t"+"dt")") = U + ((del U)/(delx), (del U)/(delt)) ((dx),(dt))`
`Ucolor(#006090)((vecs"+"vec(ds))) = U + (delU)/(delvecs) vec(ds)`
`Ucolor(#006090)((vecs"+"vec(ds))) = U + U' vec(ds)`
Selon la déclaration des neurones, nous avons `Ucolor(#006090)((vecs)) = Ucolor(#006090)("("x,t")")`. Notez que le produit `U'vec(ds)` est un produit matriciel. Dans l'infiniment petit, une fonction dérivable quelconque `U` apparait localement comme une fonction linéaire de matrice `U'`. La dérivé du champ `U` qui se note `U'` est une matrice (ici une matrice ligne, un vecteur horizontal) :
` U' = (dU)/(dvecs)= ((del U)/(delx), (del U)/(delt))`
Toute équation différentielle partielle du second ordre linéaire est équivalente à deux équations différentielles partielles du premier ordre linéaire. Ainsi l'équation différentielle suivante :
`(del^2U)/(delx^2) = 1/c^2(del^2U)/(delt^2)`
est équivalente au système différentiel suivant :
`(del U)/(delx) = 1/c (del V)/(del t)`
` (del V)/(delx) = 1/c (del U)/(del t)`
En effet, on déduit de ces deux équations que :
`(del^2 U)/(delx^2) = 1/c (del^2 V)/(del t delx)`
` (del^2 V)/(delxdelt) = 1/c (del^2 U)/(del t^2)`
Et donc on en déduit la première équation. Nous avons choisie une décomposition symétrique en deux champs `U` et `V` qui jouent de manière analogue le rôle du champ électrique `U` et du champ magnétique `V`.
Le champ `U` est scalaire, c'est à dire qu'à chaque instant `t` et à chaque position `x` il est égale à une seule valeur réelle `Ucolor(#006090)("("x,t")")`. On dira que le champ n'a qu'une seule dimension, qu'un seul degré de liberté, ou bien qu'une seule composante vectorielle.
Mais il est possible de considérer plusieurs tels champs, et de les superposer non pas en les ajoutant mais en les juxtaposant en autant de nouvelle dimension voulue, superposition sans qu'il n'y ait aucune interaction entre eux, c'est à dire en les ajoutant sur des composantes de dimension différentes du champ, chaque dimension représentant un degré de liberté différents et indépendant des autres. Le champ devient vectoriel et possède plusieurs composantes, plusieurs dimensions, plusieur degrés de liberté. Chaque dimension correspond à un degré de liberté, et correspond à une composante du champ. Et il peut y en avoir autant que l'on veut, formant ainsi un paralélisme de calcul mis en oeuvre par le calcul matricielle. Considérons un champ vectoriel `vecU` comprenant par exemple 3 composantes que l'on numérote de 1 à 3 :
`vecU = ((U_1),(U_2),(U_3)) vecU color(#006090)("("x,t")") = ((U_1color(#006090)("("x,t")")),(U_2color(#006090)("("x,t")")),(U_3color(#006090)("("x,t")")))`
Cela correspond à 3 champs indépendants que l'on regroupe en un seul champ possédant trois dimensions, trois degrés de liberté, c'est à dire trois composantes. La dérivée partielle du champ vectoriel `vecU` selon chaque axe est définie comme suit :
`(delvecU)/(delx) = (((delU_1)/(delx)),((delU_2)/(delx)),((delU_3)/(delx)))` `(delvecU)/(delt) = (((delU_1)/(delt)),((delU_2)/(delt)),((delU_3)/(delt)))`
Et nous pouvons calculer le champ vectoriel au point `(x"+"dx, t "+"dt)` comme suit :
`vecUcolor(#006090)("("x"+"dx,t"+"dt")") = vecU + (del vecU)/(delx)dx + (del vecU)/(delt)dt`
Cette équation se met sous forme matricielle, et met en exergue le produit matriciel de la dérivée `vecU'` par l'élément différentiel d'espace-temps `vec(ds)`:
`vecUcolor(#006090)("("x"+"dx,t"+"dt")") = vecU + ( ((del vecU)/(delx),(del vecU)/(delt)) )((dx),(dt))`
`vecUcolor(#006090)((vecs"+"vec(ds))) = vecU + (delvecU)/(delvecs) vec(ds)`
`vecUcolor(#006090)((vecs"+"vec(ds))) = vecU + vec(U)' vec(ds)`
La dérivée `vecU'` est une matrice possédant autant de colonnes qu'il y a de coordonnées (ici `x` et `t`) , et possèdant autant de lignes qu'il y a de composantes de champ (ici `1`, `2` et `3`) :
`vecU' = (delvecU)/(delvecs) = ( ( (delvecU)/(delx), (delvecU)/(delt) ) ) = ( ( (delU_1)/(delx), (delU_1)/(delt) ),( (delU_2)/(delx), (delU_2)/(delt) ),( (delU_3)/(delx), (delU_3)/(delt) ) )`
Notez que cet artifice ne fait que regrouper plusieurs champs scalaires indépendants entre-eux, en un seul champ vectoriel, et ne fait que proposer une notation qui met en oeuvre le calcul parallèle associé. Notez que le développement peut se continuer à l'ordre 2 en ajoutant le terme suivant du développement de Taylor, où la dérivé seconde, `U''`, est un tenseur de dimension 3 :
`vecUcolor(#006090)((vecs"+"vec(ds))) = vecU + vec(U)' vec(ds) + 1/2(vec(U)'' vec(ds)) vec(ds)` `vecUcolor(#006090)("("x"+"dx,t"+"dt")") = vecU + (del vecU)/(delx)dx + (del vecU)/(delt)dt + 1/2(del^2 vecU)/(delx^2)dx^2 + 1/2(del^2 vecU)/(delt^2)dt^2 + (del^2 vecU)/(delxdelt)dxdt`
Si le champ vectoriel `vecU` a comme ensemble d'arrivé l'espace vectoriel où il s'étend, la valeur de `vecU` en un point `(x,t)` est alors un vecteur du même espace. Le cas étudié ici étant unidimensionnel, le champ `vecU` est encore scalaire et se note simplement `U`.
`U`
`U' = ( ((delU)/(delx), (delU)/(delt)) )`
Le champ `U` s'enrichie d'un nouveau sens reflexif sur l'espace, et on peut lui donner comme signification, le fait qu'il désigne un flux ou plus précisément le débit d'un flux.
On présuppose donc que quelque soit le point de l'espace `x`, une substance circule avec un débit `Ucolor(#006090)("("x,t")")`. Et comme le champ `U` est dérivable, cela signifie que dans un élément différentiel d'espace `dx`, toute la substance présente circule avec le même débit au premier ordre. Il découle de ce concept la notion de densité en chaque point que l'on représente par la variable d'état `rhocolor(#006090)("("x,t")")`, et qui est un réel pouvant être négatif traduisant l'équilibre des flux d'entrée et des flux de sortie dans chaque élément différentiel d'espace.
`rho"←"(x,t)`
Cette densité `rhocolor(#006090)("("x,t")")` est définie à une constante près que l'on note `rho_0` et qui représente la densité de la substance dans l'espace initial vide de champ.
Avec cette notion de flux, apparaît un sens nouveau pour certain opérateur de dérivée et que l'on renomme en conséquence tel que la divergence `"div"` qui est définie unidimensionnellement comme suit :
`"div"U = (delU)/(dx)`
Comme son nom l'indique, elle exprime la divergence : Lorsque la divergence est positive le flux se disperse. Et lorsque la divergence est négative le flux se concentre. C'est donc elle qui va présider l'évolution de la densité. Cela se traduit par l'équation de conservation de la substance :
`(delrho)/(delt) = (delU)/(dx)`
Ou dit autrement :
`dot rho = "div" U`
Un flux se caractèrise par un champ de débit du flux. La nature du flux n'est pas précisée. Le seul caractère retenu est qu'il possède un débit en tout point et à tout instant défini par `U`. Et donc qu'il y a une densité en tout point et à tout instant caratérisé par un réel qui peut être négatif et qui traduit l'équilibre des flux d'entrés et des flux de sortie pour chaque élément différentiel d'espace, et qui satisfait donc l'équation `dot rho = "div" U`.
Cette équation locale ne se résoud qu'à une constante près `rho_0` qui reste inconnue comme l'est la nature du flux, de sa substance. En considérant un espace infini et un champ d'énergie fini, cette constante `rho_0` désigne la densité à l'infini.
Notez que d'autres constructions sont possibles en interprétant la valeur du champ `U` différemment, mais celle-ci reste une des plus simples, et donc participe des premières constructions d'univers.
L'éléctromagnétisme se déduit de la relativité restreinte appliquée aux forces électriques, et donc, déduit l'essentiel de ses propriétés du seul principe d'invariance de la vitesse de la lumière `c` lors des changements de référentiel en translation uniforme.
Fort de ce constat, on choisi d'exiber des flux particulièrement simples qui possèdent une même vitesse `c` dans tous les référentiels en translation uniforme, et que nous appellons flux de champ. Les premiers flux que nous envisagerons auront donc cette vitesse de propagation invariante, `c`.
Puis, comme cette constante fondamentale est déterminée de façon exacte, on choisie un système d'unité où `c` est égale exactement à une unité de vitesse, ou si vous préféré, à l'unité de distance divisé par l'unité de temps. Délors, la constante `c` disparait des formules, et l'unité de temps se confond avec l'unité de distance puisqu'elle s'en différencie d'un facteur `c"="1` unité de vitesse.
Un référentiel correspond à un observateur qui veut prendre des mesures dans son référentiel à lui.
Les changements de référentiel dans l'espace-temps d'espace unidimensionnel s'expriment de manière élégante dans un formalisme bidimensionnel. Le référentiel détermine un système de coordonnées de l'espace-temps avec une coordonnée de temps `tau` et une coordonnée d'espace `x`. La coordonnée de temps est multipliée par la constante fondamentale `c"="1` qui est égale à une unité de longueur divisé par une unité de temps. Ceci afin d'avoir un bivecteur homogène. Conventionellement, on désigne un bivecteur position par une majuscule `X` :
`X= [(tau),(x)]`
Si le bivecteur position `X` désigne la position d'une particule, alors la variable `x` dépend du temps du référentiel, noté `t`, et forme une courbe qui constitue la trajectoire de la particule, ce qui se note par le neurone `x"←"(t)`. Et la variable `tau` dépend également du temps `t` du référentiel, et détermine ainsi un écoulement du temps propre à la particule dans le référentiel, ce qui se note par le neurone `tau"←"(t)`. Et on résume cela par le neurone `X"←"(t)`.
Dans un espace unidimensionnel, on a vite fait le tour des changements de référentiel possibles. Les changements de référentiel fixe sont engendrés par les déplacement dans l'espace-temps à la position `P`, noté `bbD(P)`, et par deux autres changements de référentiel fixe que sont l'inversion du sens de l'espace, `bbsigma_x`, et l'inversion du sens du temps, `bbsigma_t`. Peut-être y en a-t-ils d'autres encore, mais pour l'instant nous supposons qu'il n'y en a pas d'autre.
`X^(bbD(P)) = X-P`
`X^(bbsigma_x) = ((1,0),(0,-1))X`
`X^(bbsigma_t) = ((-1,0),(0,1))X`
Puis on ajoutera les changements de référentiel en translation uniforme de vitesse `v`, noté `bbT(v)` dans lesquels les origines spacio-temporelle coïncident et qui sont donc caractérisés seulement par une vitesse positive ou négative. Les autres changements de référentiel en translation uniforme s'obtiennent en combinant ceux-ci avec les changements de référentiel fixe vus précédement.
`X^(bbT(v)) = 1/(sqrt(1-v^2)) ((1,-v),(-v, 1))X`
Nous avons définie 5 types de changement référentiel laissant invariant la norme de la vitesse de la lumière dans le vide.
Leur compositions forme le groupe des transformations de Lorentz pour un univers à une dimension d'espace. Leur composition satisfont les règles suivantes :
`bbD(P)bbD(Q) = bbD(P+Q)` `bbD(P)^-1 = bbD(-P)`
`bbsigma_xbbsigma_x=1`
`bbsigma_tbbsigma_t=1`
`bbsigma_tbbsigma_x=bbsigma_xbbsigma_t=-1``bbD(P)bbsigma_x =bb sigma_xbbD(Pbbsigma_x)`
`bbD(P)bbsigma_t = bbsigma_tbbD(Pbbsigma_t)``bbT(v)bbT(w) = bbT((v+w)/(1+vw))`
`bbD(P)bbT(v) = bbT(v)bbD(PbbT(v))`
`bbsigma_xbbT(v) = bbT(-v)bbsigma_x`
`bbsigma_tbbT(v) = bbT(-v)bbsigma_t`
`bbT(v)^-1 = bbT(-v)`
`bbxi(k)bbxi(m) = bbxi(km)`
`bbD(P)bbxi(k) = bbxi(k)bbD(kP)`
`bbsigma_xbbxi(k)=bbxi(k)bbsigma_x`
`bbsigma_tbbxi(k)=bbxi(k)bbsigma_t`
`bbT(v)bbxi(k) = bbxi(k)bbT(v)`
Il apparait 4 types de changement de référentiel selon qu'il y a eu inversion de l'espace et de temps, tous caractérisé par une translation uniforme de paramètre `v in RR` et avec un second membre correspondant à un déplacement au point `[tau_0,x_0] in RR^2`, et un changement d'échelle `e in RR^"+""*"`. De telle sorte que, partant du référentiel du laboratoire `Omega`, on peut définir tout référentiel en translation uniforme avec déplacement et inversion éventuelle de l'espace et du temps, par 3 paramètres réels, un paramètre réel positif non nul et deux paramètres booléens :
`(tau_0, x_0, v, e, s_x, s_t)`
La physique des particules constate une curieuse propriété qui touche à la nature profonde des particules, c'est que la désintégration d'une particule, en dehors de toute interaction contingente, est totalement aléatoire, c'est à dire que sa probabilité de désintégration est uniforme dans l'avenir tant qu'elle n'a pas déjà été désintégrée. Autrement dit, la probabilité différentielle de désintégration est proportionnelle à la durée de l'intervalle différentiel d'avenir considéré. Le taux de proportionnalité temporel est noté `lambda`. La probabilité de désintégration de la particule dans l'intervalle `[t,t"+"dt]`, si elle n'a pas déjà été désintégrée avant, est `lambda dt`.
`P_"desintegration"("["t,t"+"dt"]") = lambda dt`
Cela décrit également des systèmes qui ne vieillissent pas, qui n'ont ni usure, ni effet de mémoire, mais qui possède un taux de désintégration spontanée constant.
Une grande quantité de particules ayant un taux de désintégration spontanée constant `lambda`, sera réduite de moitier en un temps appelé temps de demi-vie noté `t_(1/2)`, tandis que le temps moyen de vie d'une particule sera noté `T_"moy"`. La statistique démontre que :
`t_(1/2) = ln(2)/lambda`
`T_"moy"=1/lambda`
Le bivecteur position d'une particule est :
`X = ((ct),(x))` dans le référentiel `(ccR)`
`X' = ((ct'),(x'))` dans le référentiel `(ccR')`
Dans le référentiel `(ccR)`, la position `x` de la particule est une fonction du temps `t`, ce qui se note par le neurone `x"←"t`, ce qui signifie que `x` est entièrement déterminé par `t` et de manière analytique c'est à dire indéfiniment dérivable et développable. De même, dans le référentiel `(ccR')`, la position `x'` de la particule est une fonction du temps `t'`, ce qui se note par le neurone `x'"←"t'`.
le changement de coordonnées qui s'opère lors du changement de référentiel passant du référentiel `(ccR)` au référentiel `(ccR')` défini au chapitre 7. est la tranformation de Lorentz suivante :
`t’ = (t-v/(c^2)x)/sqrt(1-(v^2)/(c^2)`
`x’ = (x-vt)/sqrt(1-(v^2)/(c^2)`
On pose ces 3 variables `beta, gamma, ccL`, dépendant de `v` comme suit :
`beta=v/c` `beta in ["-"1,1]` `gamma = 1/sqrt(1 - beta^2)` `gamma in [1, oo[` `ccL = ((gamma,-beta gamma),(-beta gamma, gamma))`
Nous avons :
`[(ct’),(x’)] = ((gamma,-beta gamma),(-beta gamma, gamma)) [(ct),(x)]`
`X' = ccLX`
Un référentiel `(ccR)` correspond à un observateur `ccR` fixé à son origine spaciale et qui veut prendre des mesures dans son référentiel à lui qui est le référentiel `(ccR)`.
La position de `ccR'` dans le référentiel `(ccR)` évolue au cours du temps `t` qui est une variable libre désignant le temps dans le référentiel `(ccR)`. Sa trajectoire est décrite par son bivecteur position `X "=" [ct, x]` dans le référentiel `(ccR)` où la variable libre `t` désigne le temps dans le référentiel `(ccR)` et où `x` dépend de `t` ce qui se note `x"←"t`. Le référentiel `(ccR')` étant en translation uniforme de vitesse `v` dans le référentiel `(ccR)`, nous avons :
`x=vt`
Puis, on applique le changement de référentiel pour voir comment est vue cette particule `ccR'`, correspondant à l'origine spaciale du référentiel `(ccR')` dans le référentiel lui-même `(ccR')` c'est à dire par l'observateur `ccR'` lui-même :
`X' = ccL X`
`[(ct’),(x’)] = ((gamma,-beta gamma),(-beta gamma, gamma)) [(ct),(x)]`
`ct’ = gamma c t - beta gamma x = gamma(ct-beta vt) = gamma(ct-beta^2ct) = gamma(1-beta^2)ct = (ct)/gamma`
`x’ = 0`
La variable `t'` constitue le temps propre de la particule `ccR'` dans le référentiel `(ccR)`. C'est le temps qu'afficherait une horloge placée au coeur de la particule `ccR'` et qui serait vu dans le référentiel `(ccR)`, mais sans tenir compte de l'effet Doppler qui constitue une sorte d'effet relativiste du premier ordre. Autrement dit, c'est le temps qu'afficherait une horloge placée au coeur de la particule `ccR'` et qui serait vu dans le référentiel `(ccR)` à l'aide de moyen de communication instantané.
Ce temps propre habituellement désigné par `tau=t'` est dépendant de la variable libre `t` désignant le temps dans le référentiel `(ccR)`, ce qui se note `tau"←"t`. Et il ne coincide pas avec le temps `t`, il est ralenti, il est multiplié par le facteur `gamma^-1` :
`tau= t/gamma`
Ce temps `tau` est le temps qu'afficherait une horloge placée au coeur de la particule `ccR'` mais vu dans le référentiel `(ccR)` à l'aide de moyen de communication instantané.
Et, ce qui peut paraître paradoxal, c'est que la situation est parfaitement symétrique. On considére une particule `ccR` correspondant à l'origine du référentiel `(ccR)` et jouant également le rôle d'observateur. Le temps propre de la particule `ccR` dans le référentiel `(ccR')` est le temps qu'afficherait une horloge placée au coeur de la particule `ccR` et qui serait vu dans le référentiel `(ccR')` à l'aide de moyen de communication instantané. Ce temps propre est dépendant de la variable libre désignant le temps dans le référentiel `(ccR')`. Et il ne coincide pas, il est ralenti, il est multiplié par le même facteur `gamma^-1` :
Ce temps propre est le temps qu'afficherait une horloge placée au coeur de la particule `ccR` mais vu dans le référentiel `(ccR')` à l'aide de moyen de communication instantané.
On a donc deux temps propres qui sont identiques, le temps propre de la particule `ccR` vu par `(ccR')` et le temps propre de la particule `ccR'` vu par `(ccR)`, et que l'on note par `tau`. Si les origines spacio-remporelles des deux référentiels ne coïncidaient pas, ces deux temps propres auraient un décalage constant, mais leur variations seraient toujours égales (qu'elles soient fonction de `t` ou de `t'`), et sont noté par un unique symbole `d tau`.
Les particules ont une horloge interne trés concrète qui s'exprime par leur temps de demi-vie. Lorsque deux particules sont en mouvement l'une par rapport à l'autre d'une vitesse `v`, chacune des particules voit l'autre avec une horloge ralentie, et donc avec une demie-vie rallongée d'un même facteur `gamma`.
Pour lier ces deux horloges, ce qui est impossible dans l'absolu, il faut un troisième référentiel `(ccR'')` qui définit la simultanéitude. Car en effet, des évènements dans des lieux distincts peuvent se réaliser en même temps pour un observateur, et dans des instants différents pour un autre observateur qui serait en translation uniforme par rapport au premier observateur. La simultanéité d'évènements dans des lieux distincts est toujours relative à un référentiel. Par contre si les lieux coïncides, la simultanéité y est bien définie dans l'absolu. Ainsi, si les deux observateurs se recroisent, leurs horloges internes pourront alors être comparées dans l'absolu.
Etant donné deux évènements représentés par deux bivecteurs `X = [ct,x]` et `X' =[ct',x']`. Dans l'espace-temps, le produit scalaire de `X` par ` X'` est défini différement que dans un espace vectoriel. Dans l'espace-temps, il est définie comme suit :
`X"⋅"X' = -c^2t t'+x x'`
Les composantes temporelles sont multipliées mais le résultat est négativé tandis que les composantes spaciales sont multipliées pareillement que dans le produit-scalaire vectoriel. A l'aide de ce produit scalaire d'espace temps, on définie la distance dite d'univers entre deux évènements `X` et `X'` :
`(X"-"X')^2 = (X"-"X')"⋅"(X"-"X') = [ct"-"ct',x"-"x']"⋅"[ct"-"ct',x"-"x'] = - c^2(t"-"t')^2 + (x"-"x')^2`
Les transformations de Lorentz `ccL` laisse invariant le produit scalaire d'espace-temps et donc également les carrés des distances d'univers :
`(ccLX)"⋅"(ccLX') = X"⋅"X'`
`(ccLX"-"ccLX')^2 =(X"-"X')^2`
La transformation de Lorentz, est la transformation la plus simple qui laisse invariant le produit scalaire d'espace-temps.
Etant donné deux référentiels `(ccR)` et `(ccR')` dont les origines spacio-temporelles coïncident et où `(ccR')` est en translation uniforme de vitesse `v` dans `(ccR)`.
---- 19 octobre 2019 ----
Le bivecteur vitesse propre d'une particule est :
`V = (dX)/(d tau)` dans le référentiel `(ccR)`
`V' = (dX')/(d tau)` dans le référentiel `(ccR')`
où `tau` est le temps propre de la particule en mouvement, c'est à dire le temps qu'indique l'horloge de la particule `ccR` dans le référentiel `(ccR')` et aussi le temps qu'indique l'horloge de la particule `ccR'` dans le référentiel `(ccR)`.
`d tau = (dt)/gamma = (dt')/gamma`
Dans le cas d'un mouvement univorme de vitesse `v` entre les deux référentielles, nous avons
`(cdt) /(d tau) = (cdt) /(gamma^-1 dt) = cgamma`
`(dx) /(d tau) = (dx) / (gamma^-1 dt) = gamma (dx)/(dt`
Et donc :
`V = (( gammac),( gamma dx"/"dt))`
On remarquera que le module d'un bivecteur vitesse `V^2` vaut toujours `c` :
V^2 = -gamma^2c^2+gamma^2v^2
---- 19 octobre 2019 ----
voir aussi la contraction des longueurs
Le bivecteur position `X'` dans le référentel `(ccR')` s'obtient en appliquant la transformation de Lorentz `ccL` au vecteur position `X` dans le référentiel `(ccR)`
`X' = ccLX`
`ccL = ((gamma,-beta gamma),(-beta gamma, gamma))`
`beta=v/c`
`gamma = 1/sqrt(1 - beta^2)`
Le temps propre `tau` de la particule étant le même pour chaque référentiel, les formules de transformation du bivecteur vitesse sont donc identiques à celles du bivecteur position.
`V' = ccLV`
---- 12 octobre 2019 ----
Un espace unidimensionnels peut ne pas être une droite indéfinie. Il existe quelques modes alternatifs particulièrement simples qu'il convient de connaître. L'espace peut être recourbé pour former un cercle c'est à dire un segment `[0,L]` dans lequel on a rejoint les deux bouts. Et il y a deux façons de rejoindre les deux bouts, soit en laissant le champ identique, ou soit en inversant le signe du champ. Cela se traduit par une équation supplémentaire, dite condition aux limites :
Réunion des deux bouts avec champ identique `Ucolor(#006090)("("0,t")")=Ucolor(#006090)("("L,t")")`
Réunion des deux bouts avec champ de signe inversé `Ucolor(#006090)("("0,t")")=-Ucolor(#006090)("("L,t")")`
Si le champ est vectoriel, la combinaison des deux bouts peut non seulement s'accompagner de changement de signes pour des composantes du champs, mais également être accompagné par une permutation des composantes du champs.
L'espace peut être un segment où les bout se comportent comme des miroirs. Et il y a deux sortes de miroir, le miroir temporel et le miroir spatial. Dans un miroir temporel la dérivée du champ selon `t` est toujours égale à zéro, autrement dit le champ est fixe, et comme on le centre en zéro, le champ est toujours égale à zéro. Dans un miroir spatial la dérivée du champ selon `x` est toujours égale à zéro. Le miroir temporel correspond à un noeud de l'onde, tandis que le miroir spatial correspond à un ventre de l'onde. Cela se traduit par des équations supplémentaires, dites conditions aux limites :
Miroir temporel en `0` `Ucolor(#006090)("("0,t")")=0` Miroir temporel en `L` `Ucolor(#006090)("("L,t")")=0`
Miroir spatial en `0` `(delU)/(delx) color(#006090)("("0,t")")=0` Miroir spatial en `L` `(delU)/(delx) color(#006090)("("L,t")")=0`
Toutes ces conditions aux limites étant linéaires homogènes comme l'est l'équation locale, le principe de superposition s'applique : Si un champ `U` et un champ `V` les satisfont, alors le champ `U+V` les satisfait aussi (toutes les combinaisons liniaires de `U` et `V` les satisfont aussi). On peut donc ajouter les ondes pour former d'autre ondes qui satisfairont les mêmes équations. Ceci va nous permettre de décomposer l'onde en une sommation d'ondes élémentaires. Contrairement au cas de dimension zéro d'espace, l'équation locale de l'onde sur un espace unidimensionnel permet de définir des signaux riches contenant tout un spectre de fréquence.
On procède à un maillage de l'espace en des segments égaux à `dx` et un maillage du temps en des segments égaux à `dt`. Nous établissons l'équation aux mailles en première aproximation à partir de l'équation locale comme suit, et le calcul devient approximatif car `dx` et `dt` ne sont plus des éléments différentiels mais correspondent à la taille d'une maille :
`(Ucolor(#006090)("("x"+"dx,t")")-2U+Ucolor(#006090)("("x"-"dx,t")"))/(dx^2) = 1/c^2(Ucolor(#006090)("("x,t"+"dt")")-2U+Ucolor(#006090)("("x,t"-"dt")"))/(dt^2)`
Cette égalité permet de déterminer `Ucolor(#006090)("("x,t"+"dt")")` en fonction de `U,Ucolor(#006090)("("x"+"dx,t")"),Ucolor(#006090)("("x"-"dx,t")"),Ucolor(#006090)("("x,t"-"dt")")` :
`Ucolor(#006090)("("x, t "+" dt")") =k^2Ucolor(#006090)("("x "+" dx, t")") + k^2Ucolor(#006090)("("x "-" dx, t")") +2(1"-" k^2)U - Ucolor(#006090)("("x, t "-" dt")")` avec
`k=cdt/dx`
On adopte la convention d'écriture suivante :
`U_(:x"+"1:) =Ucolor(#006090)("("x"+"dx,t")")`
`U_(:x"-"1:)=Ucolor(#006090)("("x"-"dx,t")")`
`U_(:t+1:)=Ucolor(#006090)("("x,t"+"dt")")`
`U_(:t-1:)=Ucolor(#006090)("("x,t"-"dt")")`
L'équation aux mailles devient :
`U_(: t "+" 1:) =k^2U_(:x "+" 1:) + k^2U_(:x "-" 1:) +2(1"-" k^2)U - U_(: t "-" 1:)` avec
`k=cdt/dx`
Nous établissons l'équation aux mailles des dérivées partielles de `U` en première approximation à partir des définitions des dérivées partielles comme suit :
`(delU)/(delx) =(U_(:x"+"1:)-U)/(dx)`
`(delU)/(delt) =(U_(:t"+"1:)-U)/(dt)`
Les conditions initiales sont un champ `U` à l'instant `0` nul partout et un champ `dotU` à l'instant `dt` nul partout sauf au point milieu `L"/"2` où il vaut `1`. On pose une condition initiale équivalente à une pichenette sur le point milieu :
`AAx, Ucolor(#006090)("("x,0")")"="0`
`AAx"≠"L"/"2, dotUcolor(#006090)("("x,0")")"="0`
`dotUcolor(#006090)("("L"/"2,0")")"="1`
Et donc :
`AAx, Ucolor(#006090)("("x,0")")"="0`
`AAx"≠"L"/"2, Ucolor(#006090)("("x,dt")")"="0`
`Ucolor(#006090)("("L"/"2,dt")")"="dt`
On constate que le système ne diverge pas si et seulement si `k in ]0,1]` c'est à dire si et seulement si la vitesse de propagation d'onde, `c`, satisfait la condition suivante :
`c ≠ 0`
`c ⩽ dx/dt`
Et il existe donc une valeurs entière de `k` où le calcul peut s'effectuer de façon exacte (combinaison linéaire à facteurs entiers) qui est `k=1` et qui correspond au cas où `c=dx/dt`.
Etant donné un signal `S` de période `T` ne contenant pas de composante de fréquence supérieur ou égale à `N/T :
`S"←"t` `S(t+T)=S(t)`
Le théorème de l'échantillonnage de Shannon dit qu'un signal ne contenant pas de composante de fréquence supérieure ou égale à `N"/"T` peut être échantillonné en `2N` mesures espacées régulièrement dans le temps sur la période `T`, et sans qu'il n'y ait aucune perte de données, ce qui se note comme suit :
`S:=(S_0,S_1,S_2,...,S_(2N-1))_T`
Le paramètre `T` peut être sous-entendu et ommis. L'intervalle de temps entre deux échantillons successifs est `T"/"(2N)`, et donc la fréquence d'échantillonnage est `2N"/"T` tandis que la fréquence de répétition du signal est `1"/"T`. Après cet échantillonnage, chaque terme `S_n` est égale à la valeur de `S` à l'instant `nT"/"(2N)`.
`S_n = S((nT)/(2N))`
`S_n = S_(n mod (2N))`
Réciproquement, à partir d'un échantillonnage `(E_0,E_1,E_2,...,E_(2N-1))_T`, on peut définir un signal qui passe par tous les points de l'échantillonnage `(nT"/"(2N), E_n)` et qui, d'après le théorème de l'échantillonnage de Shannon, est unique s'il ne contient aucune composante de fréquence supérieure où égale à `2N"/"T`. On note ce signal `S`.
`S"←"t` (Pour indiquer que `S` est par défaut une fonction de `t`)
`S:=(S_0,S_1,S_2,...,S_(2N-1))_T`
Le signal `S` produit par cet échantillonnage `(E_0,E_1,E_2,...,E_(2N-1))_T` est parfaitement déterminé. Il passe par tous les points de l'échantillonnage `(nT"/"N, E_n)`, il est périodique de période `T`, et ne contient aucune composante de fréquence supérieure où égale à `N"/"(2T)`.
---- 22 janvier 2019 ----
Considérons un signal `S` de période `T` ne possédant pas de fréquence supérieure ou égale à `N"/"(2T)`. D'après le théorème d'échantillonnage, ce signal peut être échantillonné en `N` mesures espacées régulièrement dans le temps sur la période `T` sans qu'il n'y ait aucune perte d'information. cela se note comme suit :
`S ":=" (S_0,S_1,S_2,...,S_(N-1))_T`
Le signal `S` étant périodique de période `T` et ne possédant pas de fréquence supérieure ou égale à `N"/"(2T)`, il contient les fréquences `0,1"/"T,2"/"T,3"/"T,...,(N-1)"/"(2T)` lorsque `N` est impaire, et `0,1"/"T,2"/"T,3"/"T,...,(N"-"2)"/"(2T)` lorsque `N` est paire.
Tout signal sinusoïdal se décompose en la somme de deux spinos conjugués. Et donc, chaque composante de fréquence `n"/"T` se décompose en deux spinos de fréquences `n"/"T` et `"-"n"/"T`. Puis, le signal étant périodique avec une période `T`, on remarque que le spino de fréquence `"-"n"/"T` est égale au spino de fréquence `(N"-"n)"/"T` et de même valeur initiales conjuguées. On en conclu que le signal `S` se décompose en `N` spinos de fréquences `0,1"/"T,2"/"T,3"/"T,..., (N"-"1)"/"T` ce qui se note comme suit :
`S = hatS_0 + hatS_1"⟲"_(1/T) + hatS_2"⟲"_(2/T) + ... + hatS_(N-1)"⟲"_((N-1)/T) `
ET ce qui se note à l'aide d'un itérateur somme comme suit :
`S = sum_(k=0)^(N-1) hatS_k"⟲"_(k/T)`
Et on conclut que les complexes `hatS_n` et `hatS_(N-n)` sont conjugués :
`hatS_n = bar(hatS_(N-n))`
La liste des complexes caractéristiques de ces spinos c'est à dire leur valeur initiale, que l'on note avec la même lettre mais avec un chapeau `(hatS_0,hatS_1,hatS_2,...,hatS_(N-1))`, forme un échantillonnage de période `T` produisant le signal complexe `hatS`
`hatS"←"t` (Pour indiquer que `hatS` est par défaut une fonction de `t`)
`hatS := (hatS_0,hatS_1,hatS_2,...,hatS_(N-1))_T`
Ce signal complexe `hatS` constitue la transformée de Fourier de `S`.
Pour rendre plus lisible les formules, on utilisera l'indice `n` dans le premier échantillonnage, et on utilisera l'indice `k` dans le second échantillonnage. :
`S = sum_(k=0)^(N-1) hatS_k"⟲"_(k/T)`
`S = sum_(k=0)^N hat(S)_k[1,kt"/"T] `
Pour vérifier cela, il suffit de vérifier l'égalité pour chaque point de l'échantillonnage c'est à dire à chaque instant `t=nT"/"N` où `n` est un entier variant de `0` à `N"-"1`. Par défaut le signal `S` est une fonction de `t`.
`Scolor(#006090)((t)) = sum_(k=0)^N hat(S)_k[1,kt"/"T] `
`Scolor(#006090)((nT"/"N)) = sum_(k=0)^N hat(S)_k[1,k(nT"/"N)"/"T]= sum_(k=0)^N hat(S)_k[1,nk"/"N] `
`S_n = sum_(k=0)^(N-1) hat(S)_k[1,nk"/"N] `
Ce qui est la définition de la transformée de Fourier discrète inverse.
---- 20 janvier 2019 ----
Ce signal complexe `hats` constitue la transformée de Fourier discrète de `S`. Le caractère discrèt de la transformée ne fait que supprimer les fréquences au dessus ou égale à un seuil qui est ici égale à `N"/"(2T)`.
La transformée de Fourier discrète de cet échantillonnage produit un nouvel échantillonnage :
` (hatS_0,hatS_1,hatS_2,...,hatS_(N-1))_T "=:" hatS `
Et `hatS`constitue la transformée de Fourier de `S`. Quels sont les propriétés de cette transformée de Fourier ?
La transformation de Fourrier discrète s'applique à un échantillonnage `(S_0,S_1,S_2,...,` `S_n,...,S_(N-1))` pour produire un autre échantillonnage `(hatS_0,hatS_1,hatS_2,...,` `hatS_k,...,hatS_(N-1))` comme suit :
`hatS_k = sum_(n=0)^(N-1) S_n e^(- i 2 pi (n k) /N) `
Ce qui s'écrit plus simplement en remplaçant l'expression du complexe unitaire `e^(- i 2 pi (n k) /N)` par `[1,"-"nk"/"N]` :
`hatS_k = sum_(n=0)^(N-1) [1,"-"nk"/"N]S_n `
Pour rendre plus lisible les formules, on utilise l'indice `n` dans le premier échantillonnage, et on utilise l'indice `k` dans le second échantillonnage. Cet échantillonnage correspond-il à ce que nous recherchons, à savoir :
`S = sum_(k=0)^(N-1) hatS_k"⟲"_(k/T)` `S = sum_(k=0)^N hat(S)_k[1,kt"/"T] `
Pour vérifier cela, il suffit de vérifier l'égalité pour chaque point de l'échantillonnage c'est à dire à chaque instant `t=nT"/"N` où `n` est un entier variant de `0` à `N"-"1`. Par défaut le signal `S` est une fonction de `t`.
`Scolor(#006090)((t)) = sum_(k=0)^N hat(S)_k[1,kt"/"T] `
`Scolor(#006090)((nT"/"N)) = sum_(k=0)^N hat(S)_k[1,k(nT"/"N)"/"T]= sum_(k=0)^N hat(S)_k[1,nk"/"N] `
`S_n = sum_(k=0)^(N-1) hat(S)_k[1,nk"/"N] `
Ce qui est la définition de la transformée de Fourier discrète inverse.
----- 19 janvier 2019 -----
Considérons un signal `S` de période `T` ne possédant pas de fréquence supérieure ou égale à `N"/"(2T)`. D'après le théorème d'échantillonnage, ce signal peut être échantillonné en `N` mesures espacées régulièrement dans le temps sur la période `T` sans qu'il n'y ait aucune perte d'information, ce qui se note :
`S ":=" (S_0,S_1,S_2,...,S_(N-1))_T`
La transformée de Fourier discrète de cet échantillonnage produit un nouvel échantillonnage :
` (hatS_0,hatS_1,hatS_2,...,hatS_(N-1))_T "=:" hatS `
Et `hatS`constitue la transformée de Fourier de `S`. Quels sont les propriétés de cette transformée de Fourier ?
----- 18 janvier 2019 -----
autrement dit, si `N` est paire, `S` est une somme de `N"/"2` signaux de périodes `oo,T,T"/"2,T"/"3,...,T"/"(N"/"2-1)`. Et si `N` est impaire, `S` est une somme de `(N+1)"/"2` signaux de périodes `oo,T,T"/"2,T"/"3,...,T"/"((N+1)"/"2-1)`.
Un signal périodique se décompose en une sommes de signaux sinusoïdaux appelées composantes du signal. Et comme chaque signal sinusoïdal se décompose en deux spinos, le signal se décompose en une sommes de spinos. Le signal `S` étant de période `T`, toutes ses composantes sont nécessairement de fréquences multiples de la fréquence `1"/"T` et d'autre part, sont inférieures à la demi-fréquence d'échantillonnage `N"/"(2T)` selon la règle de Shannon pour qu'il n'y ait pas de perte d'information dans l'échantillonnage.
Chaque composante de fréquence `n"/"T` se décompose en deux spinos de fréquences `n"/"T` et `"-"n"/"T`. Puis le signal étant périodique avec une période `T`, on remarque que le spino de fréquence `"-"n"/"T` est égale à un spino de fréquence `(N"-"n)"/"T`. On en conclu que le signal `S` se décompose en `N` spinos de fréquences `0,1"/"T,2"/"T,3"/"T,..., (N"-"1)"/"T`.
Le spino `z"⟲"_omega` correspond au signal suivant :
`z"⟲"_omega = z[1,omegat] = ze^(i2pi omegat) = |z|cos("arg"(z)"+"2 pi omega t)+i|z|sin("arg"(z)"+"2 pi omega t)`
La sinusoïde `z∿` s'optient en sommant deux spinos congugués :
où `iz∿` est la sinusoïde `z∿` avancée d'un quart de tour.`2 (iz)"∿" = z"⟲"+bar(z"⟲") = z"⟲" + bar(z)"⟳" = |z|sin("arg"(z)"+"2pi omega t)`
La transformée de Fourier discrète, appliquée au signal `S` va calculer son spectre qui est un signal complexe noté `hatS`. C'est une liste de `N` nombres complexes `("["alpha_k, varphi_k"]")_(k=0)^N` représentant `N` spinos de fréquences respectives `k"/"T` correspondante à leur place dans la liste, et d'amplitude `alpha_k` et de phase `varphi_k` :
`hatS := (hatS_0,hatS_1,hatS_2,...,hatS_k,...,hatS_(N-1))`
`hatS :=([alpha_0,varphi_0],[alpha_1,varphi_1], [alpha_2,varphi_2],...,[alpha_k,varphi_k],...,[alpha_(N-1),varphi_(N-1)])`
Chacun de ces complexes correspond à un spinos de fréquence `k"/"T` correspondante à leur place dans la liste, et constitue une composante du signal `S`. Leur somme est égale au signal `S` :
`S = sum_(k=0)^N hatS_k"⟲"_(k/T)` `S = sum_(k=0)^N hat(S)_k[1,kt"/"T] `
`S_n = S(nT"/"N) = sum_(k=0)^N hat(S)_k[1,k(nT"/"N)"/"T]= sum_(k=0)^N hat(S)_k[1,nk"/"N] `
`S_n = sum_(k=0)^N hat(S)_k[1,nk"/"N] `
Et inversement nous avons :
`hatS_k = sum_(n=0)^N S_n[1,"-"nk"/"N] ` `hatS_k = hat S(kT"/"N) = sum_(n=0)^N S_n[1,"-"n(kT"/"N)"/"T] = sum_(n=0)^N S_n[1,"-"nk"/"N]`
---- 10 janvier 2019 ----
`hatS = sum_(n=0)^N S_n[1,"-"nt"/"T] `
`hatS = sum_(n=0)^N [|S_n|,"arg"(S_n)][1,"-"nt"/"T]`
`hatS = sum_(n=0)^N |S_n| e^(i2pi("arg"(S_n)-n t"/"T))`
`hatS = sum_(n=0)^N [|S_n|,"arg"(S_n)]_(n"/"T)`
`hatS = sum_(n=0)^N overset(n"/"T)("["|S_n|,"arg"(S_n)"]")`
`hatS = sum_(n=0)^N overset(n"/"T)(S_n)` `S = sum_(k=0)^N [alpha_k,varphi_k]"⟲"_(k/T)"`
`S = sum_(k=0)^N alpha_ke^(i2pi(varphi_k+k t"/"T))`
`S = sum_(k=0)^N [alpha_k,varphi_k][1,kt"/"T]`
On considère des référentiels en translation uniforme dans notre espace unidlmensionel. Ils sont caractérisés par une position initiale et une vitesse de translation. On checher les transformations de référentiel qui laisse invariant la vitesse `c`, c'est à dire qui laisse invariante les distances d'univers `x^2-c^2t^2`.
Exemple d'onde, dans un carré où les bord sont des miroirs (temporels), avec comme condition initiale une pichenette dans la maille du milieu, et après 20 000 000 d'itérations :
Le gradient, appelé aussi le nabla dans l'espace-temps, est un opérateur défini vectoriellement comme suit :
`vec"grad" = vecnabla = ((del/(delx)),(del/(delt)))`
Le gradient appliqué à un champ scalaire `U`, calcul son gradient qui est un champ vectoriel indiquant la plus grande pente dans l'espace-temps :
`vec"grad" U = vecgrad U = (((delU)/(delx)),((delU)/(delt)))`
Ce champ vectoriel `vec"grad" U` a comme ensemble d'arrivé l'espace-temps où il s'étend.
Ainsi la valeur de `vec"grad" U` en un point de l'espace-temps désigne un vecteur du même espace-temps, et ce vecteur désigne la plus grande pente dans l'espace-temps.
Le laplacien dans l'espace-temps est un champ scalaire qui indique la divergence du gradient dans l'espace-temps :
`Delta U = ((del/(delx)),(del/(delt)))"⋅"(((delU)/(delx)),((delU)/(delt)))`
`Delta U = (del^2U)/(delx^2) + (del^2U)/(delt^2)`
Le laplacien se définie à partir du nabla comme suit :
`Delta = vecgrad^2 = vecgrad"⋅"vecgrad = ((del/(delx)),(del/(delt)))"⋅"((del/(delx)),(del/(delt)))`
`Delta = (del^2)/(delx^2) + (del^2)/(delt^2)`
Le graient ou nabla peut s'appliquer à un champ vectorielle `vecU` :
`vecgrad vecU = (((delvecU)/(delx)),((delvecU)/(delt))) = (( (((delU_1)/(delx)),((delU_2)/(delx)),((delU_3)/(delx))) ),( (((delU_1)/(delt)),((delU_2)/(delt)),((delU_3)/(delt))) ))`
Si le vecteur `vecU` est transposé, on obtient alors la dérivée transposée `U'^TT` :
`vecgrad (vecU^TT) = (((delvecU^TT)/(delx)),((delvecU^TT)/(delt))) = (( (((delU_1)/(delx),(delU_2)/(delx),(delU_3)/(delx))) ),( (((delU_1)/(delt),(delU_2)/(delt),(delU_3)/(delt))) )) = (( (delU_1)/(delx),(delU_2)/(delx) ,(delU_3)/(delx) ),( (delU_1)/(delt),(delU_2)/(delt) ,(delU_3)/(delt) ))`
`vecgrad (vecU^TT) = ((delvecU)/(del vec s))^TT = vecU'^TT`
Et on rappelle que :
`vecUcolor(#006090)("("vecs "+" dvecs")")` `= vecU + vecU' d vec s`
Sommaire :