Définition des Opérateurs des Corps construits à partir de R






Jean-François COLONNA

www.lactamme.polytechnique.fr

jean-francois.colonna@polytechnique.edu
CMAP (Centre de Mathématiques APpliquées) UMR CNRS 7641, Ecole Polytechnique, CNRS, 91128 Palaiseau Cedex, France

[Site Map, Help and Search [Plan du Site, Aide et Recherche]]
[The Y2K bug [Le bug de l'an 2000]]
[Croyez-vous que les Nombres Réels existent dans un ordinateur et que les calculs flottants sont sûrs ?]
[N'oubliez pas de visiter Une Machine Virtuelle à explorer l'Espace-Temps et au-delà où vous trouverez plusieurs milliers d'images et d'animations à la frontière de l'Art et de la Science]
(Site WWW CMAP28 : cette page a été créée le 16/03/2019 et mise à jour le 28/11/2020 11:49:37 -CET-)



/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   G E N E R A L E   D E S   O P E R A T E U R S   D A N S   L E S                                      */
/*        C O R P S   C O N S T R U I T S   A   P A R T I R   D E S   N O M B R E S   R E E L S  :                                   */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Nota :                                                                                                                     */
/*                                                                                                                                   */
/*                    Tous les operateurs arithmetiques dans                                                                         */
/*                  un corps vont etre definis recursivement                                                                         */
/*                  a partir de ceux du sous-corps grace auquel                                                                      */
/*                  le corps est defini. Soient ainsi 'a', 'a1'                                                                      */
/*                  et 'a2' des nombres Arguments dans le corps,                                                                     */
/*                  et 'r' le Resultat d'une certaine operation                                                                      */
/*                  concernant ces Arguments ; soit d'autre part                                                                     */
/*                  'R(...)' et 'I(...)' les fonctions d'acces                                                                       */
/*                  aux parties Reelle et Imaginaire generalisees                                                                    */
/*                  definissant un nombre quelconque du corps en                                                                     */
/*                  tant que vecteur compose de deux nombres du                                                                      */
/*                  sous corps.                                                                                                      */
/*                                                                                                                                   */
/*                    On a donc, par definition, pour tout nombre 'a' :                                                              */
/*                                                                                                                                   */
/*                                      a = {R(a),I(a)}                                                                              */
/*                                                                                                                                   */
/*                  'a' appartenant a un certain corps K et                                                                          */
/*                  'R(a)' et 'I(a)' appartenant au "sous-corps"                                                                     */
/*                  sK a partir duquel K est defini.                                                                                 */
/*                                                                                                                                   */
/*                    De plus, tout nombre Reel 'x' est egal a                                                                       */
/*                  son conjugue :                                                                                                   */
/*                                                                                                                                   */
/*                                      _                                                                                            */
/*                                      x = x                                                                                        */
/*                                                                                                                                   */
/*                  A partir de R (les nombres Reels) sera                                                                           */
/*                  donc construit C (les nombres Complexes),                                                                        */
/*                  qui lui-meme servira de base a Q (les                                                                            */
/*                  Quaternions, appeles aussi HC [Hyper-Complexes]),                                                                */
/*                  qui lui-meme servira de base a O (les                                                                            */
/*                  Octonions, appeles aussi HHC [Hyper-Hyper-Complexes]).                                                           */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Definition recursive des operateurs arithmetiques :                                                                        */
/*                                                                                                                                   */
/*                  r = a               <==>      {R(r),I(r)} = {R(a),I(a)}                                                          */
/*                                                                                                                                   */
/*                  r = -a              <==>      {R(r),I(r)} = {-R(a),-I(a)}                                                        */
/*                                                                                                                                   */
/*                      _                                        ____                                                                */
/*                  r = a               <==>      {R(r),I(r)} = {R(a),-I(a)}                                                         */
/*                                                                                                                                   */
/*                  r = a1 + a2         <==>      {R(r),I(r)} = {R(a1)+R(a2),I(a1)+I(a2)}                                            */
/*                                                                                                                                   */
/*                  r = a1 - a2         <==>      {R(r),I(r)} = {R(a1)-R(a2),I(a1)-I(a2)}                                            */
/*                                                                                                                                   */
/*                  r = (A.a1) + (B.a2) <==>      {R(r),I(r)} = {[A.R(a1)]+[B.R(a2)],[A.I(a1)]+[B.I(a2)]}                            */
/*                                                                                                                                   */
/*                                                                                      _____                         _____          */
/*                  r = a1.a2           <==>      {R(r),I(r)} = {[R(a1).R(a2)] - [I(a1).I(a2)],[R(a1).I(a2)] + [I(a1).R(a2)]}        */
/*                                                                                                                                   */
/*                     2                             2                2         2                                                    */
/*                  |a|                 <==>      |a|         = |R(a)|  + |I(a)|                                                     */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Exceptions au schema recursif :                                                                                            */
/*                                                                                                                                   */
/*                    Malheureusement, echappent a ce schema, deux                                                                   */
/*                  operateurs car, en effet, ils considerent chaque                                                                 */
/*                  nombre du groupe, non pas comme un vecteur                                                                       */
/*                  bidimensionnel dans le sous-groupe sous-jacent,                                                                  */
/*                  mais comme un vecteur N-dimensionnel defini dans                                                                 */
/*                  les nombres Reels. Ces operateurs d'exception                                                                    */
/*                  sont :                                                                                                           */
/*                                                                                                                                   */
/*                                      FH...Cinitialisation(...)                                                                    */
/*                                      FH...Cforme_lineaire(...)                                                                    */
/*                                                                                                                                   */
/*                  qui initialise et calcule une forme lineaire                                                                     */
/*                  respectivement. D'une part le nombre d'arguments                                                                 */
/*                  varient quand la dimension du groupe change, et                                                                  */
/*                  d'autre part, en ce qui concerne le second, l'operation                                                          */
/*                  qu'il realise dissymetrise les differentes composantes,                                                          */
/*                  la premiere etant "scalee" et "translatee", alors que                                                            */
/*                  les suivantes ne sont que "scalees"...                                                                           */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*************************************************************************************************************************************/


(Nota : les lignes d'explications qui précèdent sont des commentaires extraits des programmes ayant été utilisés pour calculer les images correspondantes. Ce programme en est un exemple parmi des centaines.)


Copyright © Jean-François Colonna, 2019-2020.
Copyright © CMAP (Centre de Mathématiques APpliquées) UMR CNRS 7641 / Ecole Polytechnique, 2019-2020.