L'algèbre transcrit des lois physiques en axiomes et constitue en quelque sorte la logique de la loi. L'algèbre constitue le modèle mathématique de l'objet physique étudié. Un objet physique peut avoir plusieurs modèles mathématiques car les lois physiques, les lois de la nature, ne sont jamais connues dans l'absolu et dépendent toujours d'hypothèses. Et qui dit hypothèses dit plusieurs possibilités.
L'algèbre constitue la partie intelligible de la loi physique, on pourrait même dire, si on osait, qu'elle constitue la partie intelligible de la réalité.
A partir de quelques axiomes rudimentaires, on construit l'espace vectoriel, un modèle pertinent de l'espace tel que nous le percevons à notre échelle. Et nous passons en revu la liste des premiers objets les plus simples que nous pouvons construire dans ce modèle mathématique, sachant qu'ils auront dés lors une interpretation physique pertinente.
L'algèbre constitue également le plan de programmation du langage formel, un langage qui se veut universel : La machine devra enregistrer les définitions des différents objets algèbriques, de la même façon que notre esprit s'en imprègne, en acquièrant le pouvoir de les agencer librement en toutes sortes de constructions posssibles.
Ce procédé de construction est utilisé sur-lui même dans l'étude intuitionniste des catégories comme une sorte d'algèbre sur l'algèbre. Elle constitue le squelette du langage formel.
L'algèbre, de part son haut degrès d'interopérabilité, possède des possibilités autonomes d'unification, et constitue en cela la raison unifiante des mathématiques et du langage formel. Nous le développerons en l'adaptant encore quelque peu à notre point de vue purement constructif et orienté sur le langage.
Puisque le raisonnement mathématique ne manipule que des formules de taille finie consructible dans un langage d'opérateurs et dans une structure libre, il est pertinent de considérer les éléments comme étant eux-même de même nature, c'est à dire de taille fini consructible dans une structure libre.
Les mathématiques étant une science exacte, avant de concevoir une théorie, ce sont les règles de déductions qu'il convient de formaliser. Cela consiste à choisir les règles de déductions que l'on s'autorise pour construire les démonstrations.
Le principe intuitionniste considére le statut de l'élément comme identique à celui des théories, les règles de construction des démonstrations sont étroitement liés aux règles de construction des éléments.
L'élément mentionné dans une formule constitue le signifiant et non le signifié. Il fait partie du langage, et à ce titre, il obéit aux lois du langages comme toutes formules ou théories exprimables.
Revisitons l'Algèbre telle qu'elle était classiquement enseignée sous le label des mathématiques modernes, mais avec une autre vision, une vision intuitionniste où tout élément doit être constructible, où toute définition doit être une construction, et où démontrer signifie construire, c'est à dire programmer.
Un ensemble est constructible s'il est énumérable, c'est à dire s'il existe un programme qui énumère tous ses éléments.
On se place dans un langage d'opérateurs comprenant :
On définie le constructeur de structure libre <...> comme un méta-opérateur d'arité variable qui prend en argument des opérateurs et qui retourne comme résultat la structure libre engendrée par ces opérateurs. Exemples :
<a> = {a}
<a,b> = {a,b}
<a,s(.)> = {a, s(a), s(s(a)), s(s(s(a)))...}
<a,g(.,.)> = {a, g(a,a), g(...}
<a,b,s(.),f(.)> = {a, s(a), f(a), b, s(b), f(b), s(s(a))...}
<a,p(...)> = {a, p( ), p(a), p(a,a), p(a,a,a) p(p( )), p(a,p( ))...}
Une structure libre est dite de type finie si elle est engendrée par un nombre finie d'éléments et d'opérateurs (mais pas par des programmes).
On définie la signature d'une structure libre de type finie comme étant une suite finie d'entiers (n0, n1, n2, n3...). L'entier n0 désigne le nombre d'opérateurs zéro-aires générateurs, l'entier n1 désigne le nombre d'opérateurs unaires générateurs, l'entier n2 désigne le nombre d'opérateurs binaires générateurs, l'entier n3 désigne le nombre d'opérateurs d'arité 3, et ainsi de suite. Par exemples :
Signature (<a, b >) = (2)
Signature (<a, f(.)>) = (1,1)
Signature (<a,b, g(.,.)>) = (2,0,1)
Signature (<a,b,c,f(.),g(.),h(.,.)>) = (3,2,1)
Les structures libres, pour chaque signature, sont uniques à isomorphisme près. Pour démontrer cela, il faut appliquer le principe de récurrence primitive qui s'appuit sur les énumérateurs de structure libre.
Une structure libre est canoniquement énumérable. Elle possède un énumérateur canonique, induisant un ordre canonique, selon la taille d'abord puis selon l'ordre de présentation. Par exemple, dans le langage {a, b, f(.), g(.), U(.,.), V(.,.)}, la structure <a, b, f, g, U, V> de signature (2,2,2) s'énumère comme suit :
a
b
f(a)
f(b)
g(a)
g(b)
f(f(a))
f(f(b))
f(g(a))
f(g(b))
g(f(a))
g(f(b))
g(g(a))
g(g(b))
U(a,a)
U(a,b)
U(b,a)
U(b,b)
V(a,a)
V(a,b)V(b,a)
V(b,b)
f(U(a,a))
f(U(a,b))
f(U(b,a))
f(U(b,b))
f(V(a,a))
f(V(a,b))
f(V(b,a))
f(V(b,b))g(U(a,a))
g(U(a,b))
g(U(b,a))
g(U(b,b))
g(V(a,a))
g(V(a,b))
g(V(b,a))
g(V(b,b))
U(a,f(a))
U(a,f(b))U(a,g(a))
U(a,g(b))
U(b,f(a))
U(b,f(b))
U(b,g(a))
U(b,g(b))
U(f(a),a)
U(f(a),b)
U(f(b),a)
U(f(b),b)U(g(a),a)
U(g(a),b)
U(g(b),a)
U(g(b),b)
U(U(a,a))
U(U(a,b))
...
Chaque élément de la structure se met sous forme d'une chaine de caractères où chaque opérateur joue le rôle d'un caractère, tel que UfaUbfa pour l'élément U(f(a),U(b,f(a))). Et on choisit l'ordre entre les opérateurs tel qu'il est définie dans la présentation de la structure (a, b, f, g, U, V).
L'énumérateur est un programme que l'on doit pouvoir écrire dans un langage de programmation. Considérons la présentation suivante <a, f(.), g(.,.)>. On commence par programmer un énumérateur des mots de {a, f, g}*. L'énumération des mots se fait par taille d'abord et par ordre des opérateurs tels qu'ils apparaissent dans la présentation. {a, f, g}* = (a, f, g, aa, af, ag, fa, ff, fg, ga, gf, gg, aaa, aaf...). L'énumérateur des mots de n caractères peut se programmer en n boucles "for" imbriquées, mais le plus astucieux consiste à programmer un compteur.
On définie un vecteur v contenant N cases mémoires numérotés de 0 à N-1 chacune pouvant contenir une valeur parmis {nil, a, f, g} où nil signifie vide. Par exemple l'opérateur U(a,f(a)) sera mémorisé comme suit :
On définie la méthode d'accès aux composantes du vecteur, v[n] désigne le contenue de la case numéro n. On définie une variable globale c contenant un entier compris entre 0 et N-1 et qui désignera la case en cours. Ainsi v[c] désignera le contenue de la case en cours. On définie le premier opérateur o1 ici égale à a, et le dernier opérateur o2 ici égale à g. On définie une autre variable globale r égale à 0 ou à 1 et qui correspond à la retenue. On définit une fonction successeur succ, qui appliquée à un opérateur de la présentation retourne l'opérateur suivant dans la présentaton, et tel que appliquée à nil ou au dernier opérateur o2, il retourne le premier opéateur o1. Cette fonction possède en plus un effet de bord, lorsqu'elle est appliqué à l'opérateur o2, elle met la variable r à la valeur 1, et lorsqu'elle est appliquée à tout autre autre opérateur, elle laisse r inchangé.
On programme la fonction next qui calcule le mot suivant, comme suit. Au départ le mot se trouve placé dans les N cases, et nous avons c=0 et r=0.
function next(){
v[c]=succ(v[c])
if r==1 then
r=0
c=c+1
next()
c=0
}
Le résultat se trouve dans les N cases. Maintenant on perfectionne le programme pour qu'il ne produise que des termes clos. On définie une fonction arité qui appliquée à un opérateur retourne son arité. On définie une variable globale k qui contient un entier et qui désigne l'arité maximale que peut avoir l'opérateur contenu dans la case en cours. Puis on adapte l'algorithme précédent pour n'énumérer que les termes clos, en ajoutant à chaque incrémentation les conditions de maximalité sur l'arité. Au dépard c=0, r=0, k=0.
function next(){
v[c]=succ(v[c])
while arité(v[c])>k do v[c]=succ(v[c])
if r==1 then
r=0
c=c+1
next()
c=0
}
---- 26 décembre 2014 ----
un opérateur noté v(.) que l'on fait opérer sur a, le premier élément de la structure, et qui définie en quelque sorte les entiers, <a,v(.)> = {a,v(a), v(v(a)), v(v(v(a)))....} = {vn(a) / n∈⓵}. La structure <a,v> vue dans le langage {a,v(.)} correspond à l'ensemble des entiers. Et la structure <a,v> munie de la définition de v, vue dans le langage {a, b, f(.), g(.), U(.,.), V(.,.), correspond à la strucure <a, b, f, g, U, V> :
Contexte Langage : {a, b, f(.), g(.), U(.,.), V(.,.)}
Contexte Définitions : {v = Eumérateur de <a, b, f, g, U, V>}<0,v> / {définition de v} = <a, b, f, g, U, V>
La structure <a, b, f(.), g(.), U(.,.), V(.,.)> doit être capable de ptogrammer cette opérateur
La notion d'énumérateur se généralise à celle de surjection constructive entre une structure dité énumérante et une structure dite énumérée. ayant le même ensemble sous-jacent. Par exemple la structure <a,b,t(.,.,.)> peut programmer un opérateur g(.,.) tel que <a,g(.,.)> = <a,b,t(.,.,.)>
Elle est capable.de programmer cet énumérateur.
:la structure libre <a, b, f(.), g(.,.)> peut programmer l' énumérateur canonique suivant :
v(.). Par exemple, la structure libre <a, b, f(.), g(.,.)> peut programmer un opérateur v(.) qui à partir d'un élément noté 0, va énumérer tous les éléménts de la structure 0, v(0), v(v(0)), v(v(v(0)))...
<0,v(.) / "Définition de v" > = <a,b,f(.),g(.,.)>
La récursivité primitive se définie de manière générale en l'appliquant à une structure autre que les entiers. La récursivité primitive met simplement en oeuvre le principe de clôture, un principe co-substantiel à la notion de structure. A savoir : Si des éléments a, b satisfont une propriété P(.), c'est à dire si nous avons P(a) et P(b), et que des opérateurs f(.), g(.,.) respectent la propriété P(.) sur la structure <a,b,f(.),g(.,.)>, c'est à dire si pour tout élément x de la structure <a,b,f(.),g(.,.)> nous avons P(x) => P(f(x)) et si pour tout couple d'éléments x et y appartenants à la structure <a,b,f(.),g(.,.)> nous avons P(x) et P(y) => P(g(x,y)), alors nous pouvons déduire par récurrence primitive que tous les éléments de la structure <a,b,f(.),g(.,.)> satisfont la propriété P(.). Nous déduisons par exemple P(g(b,f(a))).
P(a),
P(b),
∀x∈<a,b,f(.),g(.,.)>, P(x) => P(f(x)),
∀(x,y)∈<a,b,f(.),g(.,.)>2, P(x) et P(y) => P(f(x)) et P(g(x,y))
On utilise le symbôle ∈ mais appliqué à un ensemble énuméré, aussi cela ne nécessite pas de présuposer la théorie des ensembles. La structure libre <a,b,f(.),g(.,.)> retourne un prédicat qui définie son ensemble sous-jacent, et elle est en mesure de le programmer. L'expression booléenne <a,b,f(.),g(.,.)>(x) est égale à true si x appartient à la structure libre ou false sinon. On peut remplacer la formule ∀x∈<a,b,f(.),g(.,.)>, P(x) => P(f(x)) par la formule ∀x (<a,b,f(.),g(.,.)>(x) et P(x)) => P(f(x)). Puis on peut se retreindre qu'a la structure, auquel cas il est inutile de préciser l'appartenance des éléments à la structure. Ce principe de récurrence se met alors sous forme normale en une conjonction de 2*3 clauses composées chacune de 5 littéraux.
∃U ∃V ∃W, ¬P(a) ou ¬P(b) ou {
¬P(f(U)),
} ou {
P(W),
¬P(g(V,W))} ou P(x)}
Ce principe de récurrence que l'on doit pouvoir démontrer en applicant les règles de déductions, stipule, au cas ou la propiété P ne serait pas valide partout tout en étant vrai pour les éléments générateurs, l'existance d'une rupture U pour l'opérateur f ou d'une rupture (V,W) pour l'opérateur g.
|
On note une séquence de n variables comme suit : u = (u1, u2, u3...., un).
Une fonction primitive récurcive r d'arité n+1 se construit à partir de k opérateurs tels que par exemple a, b, f(.), g(.,.), formant implicitement une structure <a,b,f(.),g(.,.)>, et à partir de k fonctions r1, r2, r3...., rk, une fonction par opérateur, d'arité égale à n plus deux fois l'arité de l'opérateur. La fonction r se programme alors comme une suite d'alternative :
r(u, a) = r1(u)
r(u, b) = r2(u)
r(u, f(x)) = r3(u, x, r(u,x))
r(u, g(x,y)) = r4(u, x, y, r(u,x), r(u,y))
Notez que les dernières alternatives sont récurcives. La fonction r est réappelée dans un ou plusieurs arguments. L'opérateur r se note à l'aide du méta-opérateur d'alternative | comme suit, chaque alternative étant passée à la ligne pour plus de clarté :
r = (u, a) --> r1(u) |
(u, b) --> r2(u) |
(u, f(x)) --> r3(u, x, r(u,x)) |
(u, g(x,y)) --> r4(u, x, y, r(u,x), r(u,y))
C'est une liste d'alternatives à prendre dans l'ordre. Lors de l'appel r(w) où w est une séquence de n+1 termes clos, la fonction r va tester l'unification de w avec la première entête (u,a). Si l'unification réussi alors la fonction r retourne r1(u), et si l'unification échoue alors on passe à l'alternative suivante, etc...
La récurcivité primitive peut ainsi être construite indépendament des entiers. De tel sorte que les entiers ne sont plus une structure particulière, nécessaire à la récurrence.
La structure de magma désigne une opération binaire interne.
magma (M,*) siginife :
L'opération * est interne. ∀x∈M ∀y∈M x*y∈M
Le choix de prendre une opération interne est le choix le plus générale. Car les autres choix induisent une discrimination sans fondement, et s'obtiennent donc à partir de ce premier choix qui est le plus générale en ajoutant des prédicats au langage et les fondements manquants à la théorie. C'est pourquoi, en l'absence de précision, les ensembles de départ et les ensembles d'arrivés sont les mêmes, et que tous ces ensembles sont égaux, et, en l'absence de précision, les opérations de la structure sont internes à la structure. En conséquence la théorie du magma proprement dite est définie comme étant vide.
Il faut considérer cette définition classique du magma comme une définition logique exprimée dans une logique du premier ordre c'est à dire avec un seul type de variable élémentaire. Sa définition est :
magma (M,*) <=> ∀x∈M ∀y∈M, x*y∈M
L'équivalence est relative au système de déduction choisi complété par la théorie des ensembles. L'inconvénient de cette définition est qu'elle présuppose la théorie des ensembles, une théorie contestable lorsque les ensembles sont infinis. Pour pallier à cela, on traduit l'ensemble M par un prédicat de même nom M(.) que l'on définie comme suit :
∀x, (M(x) <=> x∈M)
La signification de ∀x est particulière à la logique intuitionniste. Elle désigne tous les éléments consructibles dans un langage mère très vaste, un langage d'opérateurs qui comprend au moins tous les opérateurs que nous allons utiliser dans notre discours. Avec cette traduction, on n'a pas besoin de la théorie des ensembles. On utilise un prédicat unaire M(.) inconnue pour désigner l'ensemble logique M. Le paradoxe de Russel ne se pose pas car tous les éléments évoqués doivent être constructibles. Le prédicat M, comme tout les opérateurs du langage, doit être calculable, mais cette calculabilité n'est pas forcement totale, à savoir qu'une opération peut ne pas donner de réponse, ce qui correspond à l'infini de Turing. Dans une première approche on évitera la problèmatique de l'infini de Turing et on ne considèrera que des opérateurs totalement calculables, c'est à dire qui correspondent à des programmes dont l'arrêt est sûr.
En écartant la théorie des ensembles, la définition du magma devient :
magma (M,*) <=> ∀x ∀y, ((M(x) et M(y)) => M(x*y))
Une théorie est écrite dans un langage d'opérateurs. On explicite le langage de la théorie que l'on présente entre crochet <...>. Par exemple :
Langage ( "∀x ∀y, M(x) et M(y) => M(x*y)" ) = < M, *>
Les guillements sont nécessaires pour signifier que l'on s'interesse à la forme de la formule, et non à ce qu'elle vaut logiquement. C'est à dire qu'elle ne doit pas être remplacée par une autre formule équivalente. Car deux formules logiquement équivalentes n'ont pas nécessairement le même langage.
Il est sous-entendu que M est un prédicat unaire, et que * est un opérateur binaire. Mais apriori, un langage d'opérateurs n'est pas sensé contenir des prédicats. En faite, le prédicat est considéré comme un opérateur. Le prédicat retourne false lorsque l'opérateur de même nom retourne FAIL, et retourne true lorsque l'opérateur de même nom retourne un résultat différent de FAIL. Le FAIL est un élément que l'on a rajouté par commodité.
Le langage d'opérateurs constitue une structure libre. Par exemple le langage {M(.),*(.,.)} augmenté d'une variable élémentaire x engendre l'ensemble <x, M(.), *(.,.)> de toutes les compositions closes qu'il est possible de construire à l'aide de ces trois opérateurs ; x, M(.) et *(.,.). De nombreux termes n'aurons pat de signification utile tel que M(M(x)) car M est un prédicat, mais qu'importe cela pourra peut-être faire l'objet d'un développment future, et l'on pense déjà à un énumérateur des éléments de M par exemple.
La présente définition du magma est implicite car elle ne fournie pas de fonction énumérative de ses éléments, mais seulement un prédicat. Et alors, pour énumérer ses éléments, il nous faut recourir à un énumérateur de tous les éléments de l'ensemble mère. Pour remédier à cela on inverse le processus de définition de la structure, en proposant un processus de construction de la structure, une construction de l'ensemble M, à l'aide d'un ensemble énumérable d'éléments générateurs. La définition du magma devient alors explicite. La structure est monogène si elle est engendrée par un élément, bigène si elle est engendrée par au moins 2 éléments, trigène si elle est engendrée par au moins 3 éléments, etc, de type fini si elle est engendrée par un nombre fini d'éléments, et de type infini énumérable si elle est engendré uniquement par des ensembles infinis énumérables d'éléments générateurs. La strutcture présente son propre fondement, le mécanisme de construction de ses éléments. La syntaxe change. Elle utilise un constructeur appelé parfois patron, "Magma monogène (.,.)" qui opère la cloture par composition close de la présentation. La structure n'est plus une simple équivalence logique, elle contient une présentation qui permet d'énumérer les éléments de son ensemble sous-jacent. Le magma monogène se déclare formellement comme suit :
M = Magma monogène (a,*)
Le premier argument a désigne l'élément générateur. Le second argument * désigne l'opération binaire libre opérant sur la structure. Et le méta-opérateur Magma monogène, appelé aussi constructeur ou patroin, retourne l'ensemble sous-jacent sous-forme d'un prédicat. Par convention le méta-prédicat implicite est noté en miniscule, par exemple magma (M,*) tandis que le méta-opérateur explicite est noté en commençant par une majuscule, par exemple Magma monogène (a,*). Le méta-prédicat magma est un opérateur du second ordre prenant en argument non pas des éléments opérateur d'arité zéro, mais d'autres opérateurs d'arité supérieur à zéro, que sont M et *, pour retourner l'élément FAIL si la structure n'est pas un magma ou pour retourner un élément différent de FAIL si la structure est un magma. De même le méta-opérateur Magma monogène est un opérateur du second ordre prenant en argument non pas des éléments opérateur d'arité zéro, mais d'autres opérateurs d'arité supérieur à zéro, que sont M et *, pour retourner un prédicat définissant l'ensemble sous-jacent de la structure. La structure Magma monogène (a,*) à la capacité de programmer un tel prédicat.
Nous pouvons de surcroît utiliser des opérateurs déjà prédéfinie, par exemple prenons * : (x,y) --> x*y le produit de deux entiers. Alors le Magma bigène (2,3,*) va engendrer l'ensemble {2x*3y / (x,y)∈⓵2} et s'avèrera un semi-groupe commutatif. La théorie de la structure regroupe la théorie du patron et les théories des opérateurs qui l'a compose. Les patrons de structures peuvent ainsi être utilisées comme constructeurs d'autres structures.
En l'absence de définition préalable, l'opérateur * est interne dans la structure et est définie par * : (x,y) --> x*y. Cela signifie que l'opération * appliquée à deux argument x et y produit le terme x*y qui constitue un arbre. Autrement dit, * est un opérateur binaire libre. Cela signifie qu'il est injectif, c'est à dire si (x1,y1) est différent de (x2,y2) alors x1*y1 est différent de x2*y2. En l'absence de définition préalable, les opérateurs d'une structure sont internes à la structure. La théorie est enrichie lorsque un opérateur n'est pas inerne, par les fondements de cette externité. Aussi on ne mentionne pas l'internité dans la théorie. La théorie du magma monogène est donc vide, et la structure de magma monogène est donc libre, ce qui se note par :
Magma monogène (a,*) = <a,*>
Il n'y à qu'un seul magma monogène libre à isomorphisme près. De même il n'y a qu'un seul magma bigène libre à isomorphisme près. Et pour chaque n entier, il n'y a qu'un seul magma n-gène libre à isomorphisme près. Pour démontrer cela, il faut appliquer le principe de récurrence primitive d'écrit au chapitre 4.
Le magma monogène représente tous les opérateurs unaires qu'il est possible de construire par composition close d'une opération binaire. Considérons un magma
magma (M,•)
La structure de péano désigne une opération unaire interne.
péano (P,s) siginife :
L'opération s est interne. ∀x∈P s(x)∈P
La définition implicite du péano est :
péana (P,s) <=> ∀x, P(x) => P(s(x))
Le premier argument P désigne l'ensemble sous-jacent du péano. Le second argument s désigne l'opération unaire opérant sur la structure. Et le meta-prédicat péano retourne true si la structure est
La définition explicite du péano monogène est :
Péano monogène (a,s) = <a,s>
Le premier argument a désigne l'élément générateur. Le second argument s désigne l'opération unaire libre opérant sur la structure. Et le constructeur Péano monogène retourne l'ensemble sous-jacent sous-forme d'un prédicat. La théorie du péano est vide.
En l'absence de définition préalable, l'opérateur * est interne dans la structure et est définie par * : (x,y) --> x*y. Cela signifie que l'opération * appliquée à deux argument x et y produit le terme x*y qui constitue un arbre. Autrement dit, * est un opérateur binaire libre. Cela signifie qu'il est injectif, c'est à dire si (x1,y1) est différent de (x2,y2) alors x1*y1 est différent de x2*y2. En l'absence de définition préalable, les opérateurs d'une structure sont internes à la structure. La théorie est enrichie lorsque un opérateur n'est pas inerne, par les fondements de cette externité. Aussi on ne mentionne pas l'internité dans la théorie. La théorie du magma monogène est donc vide, et la structure de magma monogène est donc libre, ce qui se note par :
Il n'y à qu'un seul magma monogène libre à isomorphisme près. De même il n'y a qu'un seul magma bigène libre à isomorphisme près. Et pour chaque n entier, il n'y a qu'un seul magma n-gène libre à isomorphisme près. Pour démontrer cela, il faut appliquer le principe de récurrence primitive d'écrit au chapitre 4.
La structure de semi-groupe désigne une opération interne associative. La définition implicite est la suivante :
semi-groupe (S,*) signifie :
L'opération * est interne. ∀x∈S ∀y∈S, x*y∈S L'opération * est associative. ∀x∈S ∀y∈S ∀z∈S, (x*y)*z = x*(y*z)
La théorie du semi-groupe contient seulement la propriété d'associativité de l'opérateur *.
Une théorie d'égalité est une théorie écrite avec les opérateurs du langages de la structure, le prédicat =, les variables universelles x,y,z..., et les seuls connecteurs logiques et, ou. Elle n'utilise pas la négation ni les quantificateurs existentiels. La théorie est mise entre braquette {...} qui désigne une conjonction, et les quantificateurs sont regroupés au débuts, puis sont omits, car toute variable qui n'est pas dans le langage et nécessairement quantifiée universellement pour que la théorie soit une théorie d'égalité.
Une théories d'égalité se développe en une conjonction de clauses de manière unique à l'ordre près des clauses, à l'ordre près des égalités dans chaque clause, et à une permutation près des variables universelles. La forme normale de la théorie est appelée l'expression de la théorie. Mais deux théories distinctes, c'est à dire d'expressions différentes, peuvent être logiquement équivalentes.
Une théories d'égalité définie une relation d'équivalence.
Pour la définition explicite, le semi-groupe monogène se déclare formellement par :
S = Semi-groupe (a,*)
La théorie d'égalité {(x*y)*z = x*(y*z)} définie une relation d'équivalence dans le magma monogène libre <a,*>. A partir d'une strructure et d'une théorie d'égalité, on définie la structure quotient. C'est la structure des classes d'équivalence :
Semi-groupe monogène (a,*) = Magma monogène (a,*) / {(x*y)*z = x*(y*z)}
Une structure d'égalité se développe en le quotient d'une structure libre par une théorie d'égalité. Ce quotient définie l'expression de la structure d'égalitée :
Semi-groupe monogène (a,*) = <a,*> / {(x*y)*z = x*(y*z)}
Pour rappel, les variables x,y,z, qui apparaissent dans la théorie entre braquette {...} et qui ne sont pas mentionnées dans le language de la structure, sont implicitement quantifiées universellement sur l'ensemble sous-jacent de la structure, c'est à dire ici ∀x∈S ∀y∈S ∀z∈S, et leurs produits est implicitement internes, c'est à dire ici ∀x∈S ∀y∈S x*y∈S.
Comme l'opération * est associative, l'expression d'un produit tel que x*y*z n'a pas besoin de parenthèse. On enrichie le langage en introduisant les répétitions. Ce sont les puissances entières xn où n est un entier strictement positif. Par exemples :
x1 = x
x2 = x*x
x3 = x*x*x
Ainsi la structure Semi-groupe (S,*) déclare un langage de niveau supérieur comprenant l'opération de produit * et les répétitions en notation multiplicative c'est à dire les fonctions x-->xn où n est un entier strictement positif. L'élément xn est appellé la puissance nième de x. On définie ce langage comme étant le langage de niveau 1 et qui sera présenté entre crochet =1 < >, le langage précédent étant considéré comme de niveau zéro. Le langages s'enrichie sans limite autre que constructive en utilisant le langage de programmation générale qui engendre l'arithmétique, mais on s'en tiendra pour l'instant à la répétition (le niveau 1) qui en constitue la première marche.
La programmation générale va remettre en cause bon nombre de certitudes. Il se peut qu'il existe un algorithme qui, appliqué à un couple d'éléments distincts quelconques du semi-groupe, va converger toujours vers un même élement singulier. Cet élément pourra alors être nommé et rajouté au langage. De même un tel algorithme peut converger toujours vers un sous-ensemble d'éléments indistinctement. Ce sous-ensemble pourra alors être nommé sous forme d'un prédicat calculable et être rajouté au langage. Et d'autres modes de singularisation existe probablement. Notre cécité originel ne nous permet pas pour l'instant de percevoir ces possibilités. Notre démarche constructive orienté sur le langage commence petit à petite à utiliser la programmation d'abord en se restreingnant qu'aux seuls répétitions.
Il y a plusieurs niveaux de langage selon la puissance de programmation que l'on s'autorise, et les entiers font parti du langage de programmation.
On peut nommer les répétitions x-->xn en les identifiant aux entiers n qui sont ici strictements positifs. Ainsi, on fait opérerer les entiers strictements positifs sur le semi-groupe, c'est à dire que l'on identifie chaque entier strictement positif à une fonction interne dans le semi-groupe correspondant à l'algorithme de répétition. Selon la notation française, l'application d'une fonction F à un élément x, se note justement par xF.
Si on ne souhaite pas procéder à l'identificationn, on use alors d'une fonction intermédiaire φ transformant un entiers strictemment positif en l'algoritme de répétition :
φ(n) = ( x-->xn )
La fonction φ transforme le signifiant n en le signifié x-->xn. En ce sens, elle définie un langage.
Lorsque le semi-groupe est commutatif, c'est à dire lorsque ∀x∈S ∀y∈S x*y = y*x, on adopte de préférence une notation additive, l'opération interne est notée + et s'appelle une addition, les répétitions sont notées Nx où N est un entier strictement positif et sont appellés les multiples de x. Par exemples :
1x = x
2x = x+x
3x = x+x+xLa structure commutative est déclarée par l'expression formelle Semi-groupe commutatif (S,+). Elle définie comme langage de niveau 1 ; l'opération (x,y)-->x+y, et les opérations x-->Nx où N est un entiers strictement positif. Il s'agit en faite du même langage que précédement. Les fonctions étant soient en notation multiplicative x-->xN ou soit en notation additive x-->Nx selon que l'opération du semi-groupe est en notation muliplicative c'est à dire représenté par le symbole *, ou en notation additive c'est à dire représenté par le symbole +. La forme n'est pas le fond et ne change pas le langage. On choisie la notation additive lorsque la commutativité de l'opération est connue, mais ce n'est pas une obligation. Il s'agit donc d'un choix syntaxique intervenant après la définition du langage, et non d'un choix proprement dit du langage.
Semi-groupe commutatif (S,+) =1 < + , x-->Nx § N∈⓵ > Semi-groupe commutatif (S,*) =1 < *, x-->xN § N ∈⓵> La commutativité utilisée avec la programmation générale va probablement introduire des possibilités supplémentaires qui nous sont pour l'instant invisibles, et modifer le langage. On commence par tenir compte que du seul langage de base optenue par une complexité programmative nulle, et ce langage de base, dit de niveau zéro, ne change pas en ajoutant la propriété de commutativité.
La définition logique est :
Semi-groupe commutatif (S,+) <=> {(x+y)+z = x+(y+z), x+y = y+x} Considération générale sur la catégorie des semi-groupes : Un ensemble d'applications opérants sur un autre ensemble commun, engendre par composition d'applications, un semi-groupe où l'opération interne est la composition d'applications notée °. On démontre réciproquement que tout semi-groupe (S,*) est isomorphe à un tel ensemble d'applications muni de l'opération °. Il suffit de faire opérer le semi-groupe sur lui-même par translation droite φ(x) = (y-->y*x).
Pour tout semi-groupe, il est toujours possible d'ajouter un élément neutre s'il n'existe pas déjà et de former ainsi un monoïde. Car l'application identité peut toujours être choisi pour servir d'élément neutre à un semi-groupe d'applications muni de l'opération °.
3) Monoïde
La structure de monoïde désigne un semi-groupe possédant un élément neutre.
(M,*) est un monoïde si et seulement si :
(M,*) est un semi-groupe Semi-groupe (M,*) Il existe un élément singulier noté 1 1∈M 1 est l'élément neutre de l'opération * ∀x∈M x*1 = x
∀x∈M 1*x = xLa structure est déclarée par l'expression formelle Monoïde (M,*). Le premier terme M désigne l'ensemble sous-jacent regroupant tous les élements du monoïde. Le second terme * désigne l'opération interne au monoïde et est appellé le produit. La structure de monoïde affirme qu'il existe un élément singulier appelé élément neutre, et le note par le symbole 1, ou plus explicitement par le symbole 1M lorsque plusieurs structures possédant un tel élément singulier sont en présence. Et nous avons 1M∈M. La définition est :
Monoïde (M,*) <=> {Semi-groupe (M,*), x*1 = x, 1*x = x} On enrichie le langage des répétitions en définissant la puissance zéro. On considère ainsi les puissances entières xn où n est un entier positif ou nul. Par exemples :
x0 = 1
x1 = x
x2 = x*x
x3 = x*x*xAinsi la structure Monoïde (M,*) déclare un langage de niveau 1 comprenant l'opération * appellé produit, l'élément neutre 1, et les répétitions x-->xn où n est un entier positif ou nul. L'élément xn est appellé la puissance nième de x. La définition du langage de niveau 1 est :
Lorsque le monoïde est commutatif, c'est à dire lorsque ∀x∈M ∀y∈M x*y = y*x, on adopte de préférence une notation additive, l'opération interne est notée + et s'appelle une addition, l'élément neutre est noté 0 ou plus explicitement 0M et les répétitions sont notées Nx où N est un entier positif ou nul. L'élément Nx est appellé un multiple de x. Par exemples :
0x = 0
1x = x
2x = x+x
3x = x+x+xLa structure commutative est déclarée par l'expression formelle Monoïde commutatif (M,+). Elle définie comme langage, l'opération (x,y)-->x+y, l'élément neutre 0 et les fonctions x-->Nx où N est un entier positif ou nul. Il s'agit du même langage de niveau 1mais dans lequel on a choisie la syntaxe additive.
Monoïde commutatif (M,*) =1 < *, 1, x-->xn § n∈ℕ> La définition logique est :
Monoïde commutatif (M,+) <=> {Semi-groupe commutatif (M,+), x+0 = x}
4) Groupe
La structure de groupe désigne un monoïde où chacun des éléments admet un symétrique.
(G,*) est un groupe si et seulement si :
(G,*) est un monoïde Monoïde (G,*) Il existe une opération unaire interne singulière notée x-->1/x ∀x∈G 1/x∈G Chaque élément x admet un symétrique 1/x ∀x∈G x*(1/x) = 1
∀x∈G (1/x)*x = 1La structure est déclarée par l'expression formelle Groupe (G,*). Le premier terme G désigne l'ensemble sous-jacent regroupant tous les élements du groupe. Le second terme * désigne l'opération interne au groupe et est appellé le produit. La structure de groupe affirme qu'il existe un élément neutre noté 1, et une opération interne notée (x-->1/x) appellé l'inverse ou l'opération unaire symétrique de *. L'élément 1/x est appelé le symétrique ou l'inverse de x.
Groupe (G,*) <=> {Monoïde (G,*), x*(1/x) = 1, (1/x)*x = 1} Le groupe enrichie son langage en définissant l'opération binaire / par l'égalité suivante x/y = x*(1/y). Cette opération / est appellée l'opération binaire symétrique de *, ou l'opération binaire inverse de *, ou l'opération inverse, ou simplement la division. Cette définition fait partie d'un sous-niveau supérieur du langage de base dont on ne précise pas le détail. On laisse le soin au contexte de déterminer dans quel sous-niveau de langage on se situe. La définition de l'opération binaire / doit alors être ajouté à la théorie de la structure.
(G,*) est un groupe si et seulement si :
(G,*) est un monoïde Monoïde (G,*) Il existe une opération binaire interne singulière notée / ∀x∈G ∀y∈G x/y∈G / est l'inverse de * L'opération binaire / étend l'opération unaire x-->1/x ∀x∈G ∀y∈G x/y = x*(1/y) Chaque élément x admet un symétrique 1/x ∀x∈G x/x = 1
∀x∈G (1/x)*x = 1La structure de groupe affirme qu'il existe une opération inverse notée /.
Groupe (G,*) <=> {Monoïde (G,*), x/y = x*(1/y), x/x = 1, (1/x)*x = 1} On enrichie le langage des répétitions en définissant les puissances négatives. On considère ainsi les puissances entières xn où n est un entier relatif. Par exemples :
x-3 = (1/x)*(1/x)*(1/x)
x-2 = (1/x)*(1/x)
x-1 = (1/x)
x0 = 1
x1 = x
x2 = x*x
x3 = x*x*xAinsi la structure Groupe (G,*) déclare un langage de niveau 1 comprenant l'opération de produit *, l'élément neutre 1, l'opération inverse / , et les répétitions x-->xn où n est un entier relatif. L'élément xn est appellé la puissance nième de x. La définition du langage de niveau 1 est :
Lorsque le groupe est commutatif, c'est à dire lorsque ∀x∈G ∀y∈G x*y = y*x, il est dit abélien, on adopte de préférence une notation additive, l'opération interne est notée + et s'appelle une addition, l'élément neutre est noté 0, le symétrique de x est noté -x et s'appelle l'opposé, l'opération (x,y)-->x-y s'appelle la soustraction, et les répétitions sont notées Nx où N est un entier relatif. L'élément Nx est appellé un multiple de x. Par exemples :
-3x = (-x)+(-x)+(-x)
-2x = (-x)+(-x)
-1x = -x
0x = 0
1x = x
2x = x+x
3x = x+x+xLa structure commutative est déclarée par l'expression formelle Groupe commutatif (G,+). Elle définie comme langage, l'opération (x,y)-->x+y, l'élément neutre 0, la fonction unaire x-->-x, l'opération (x,y)-->(x-y) définie par x-y = x+(-y), et les fonctions x-->Nx où N est un entiers relatif. Il s'agit du même langage de niveau 1 que précédement mais dans lequel on a choisie la syntaxe additive.
Groupe commutatif (G,+) =1 < +, 0, -, x-->Nx § N∈ℤ > Les définitions logiques sont :
Groupe commutatif (G,+) =0 < +, 0, - > Groupe commutatif (G,+) <=> {Monoïde commutatif (G,+), x+(-x) = 0} Groupe commutatif (G,+) <=> {Monoïde commutatif (G,+), x-y = x+(-y), x-x = 0} Les deux définitions logiques correspondent respectivement au langage contenant l'opérateur unaire x-->-x et au langage augmenté de l'opération binaire (x,y)-->(x-y) définie par x-y = x + (-y). On remarque que l'ajout d'opérateurs dans le langage entraine dans la théorie l'ajout des définitions de ces nouveaux opérateurs.
Trois structures arithmétiques fondamentales sont utilisées et il est pertinent de les désigner chaqu'une par un symbôle spécifique : L'ensemble ℿ des entiers strictement positifs, l'ensemble ℕ des entiers positifs ou nuls, et l'ensemble ℤ des entiers relatifs. Nous avons ⓵⊂ℕ⊂ℤ.
5) Anneau
La structure d'anneau désigne un groupe commutatif dans lequel on ajoute une seconde opération interne associative et distributive vis à vis de la première.
(A,+,*) est un anneau si et seulement si :
| (A,+) est un groupe commutatif | Groupe commutatif (A,+) |
| (A,*) est un semi-groupe | Semi-groupe (A,*) |
| * est distributive par rapport à + | ∀x∈A ∀a∈A ∀b∈A x*(a+b) = x*a + x*b ∀x∈A ∀a∈A ∀b∈A (a+b)*x = a*x + b*x |
La structure est déclarée par l'expression formelle Anneau (A,+,*). Le premier terme A désigne l'ensemble sous-jacent regroupant tous les élements de l'anneau. Le second terme + désigne l'opération d'addition interne dans l'anneau. Le troisième terme * désigne l'opération de produit interne dans l'anneau. La structure d'anneau affirme qu'il existe un élément singulier noté 0, appelé l'élément zero ou l'élément nul. La structure d'anneau affirme qu'il existe une fonction unaire interne notée -. L'élément -x est appellé l'opposé de x. La structure d'anneau définie l'opération binaire - appellée soustraction, par l'égalité suivante x-y = x+(-y).
| Anneau (A,+,*) = < +, 0, -, * > |
Anneau (A,+,*) <=> {Groupe commutatif (A,+), Semi-groupe (A,*), x*(a+b) = x*a + x*b, (a+b)*x = a*x + b*x}
|
Le langage de niveau 1 est augmenté les répétitions additives x-->Nx où N est un entier relatif, et des répétitions multiplicatives x-->xn où n est un entier strictement positif. Par exemples :
-3x = (-x)+(-x)+(-x)
-2x = (-x)+(-x)
-1x = -x
0x = 0
1x = x
2x = x+x
3x = x+x+xx1 = x
x2 = x*x
x3 = x*x*xAnneau (A,+,*) déclare un langage de niveau 1 comprenant l'opération +, l'élément nul 0, la fonction unaire opposé -, la soustraction -. l'opération *, les répétitions additives x-->Nx où N est un entier relatif, et les répétitions multiplicatives x-->xn où n est un entier strictement positif.
Anneau (A,+,*) =1 < +, 0, -, *, x-->Nx, x-->xn § N∈ℤ, n∈⓵ >
|
La distributivité de * sur + entraine que l'élément nul est absorbant :
∀x∈A x*0 = 0*x = 0
Lorsque le semi-groupe (A,*) est commutatif, c'est à dire lorsque ∀x∈A ∀y∈A x*y = y*x, l'anneau (A,+,*) est dit commutatif, mais on garde la notation multiplicative puisque la notation additive est déjà utilisée par la première opération. La structure commutative est déclarée par l'expression formelle Anneau commutatif (A,+,*). Elle définie le même langagede niveau 1 et de même syntaxe, en notation additive pour la première opération et en notation multiplicative pour la seconde opération, qui comprend l'opération (x,y)-->x+y, l'élément neutre 0, la fonction unaire x-->-x, l'opération (x,y)-->x-y, l'opération (x,y)-->x*y, puis les fonctions x-->Nx où N est un entiers relatif, et les fonctions x-->xn où n est un entier strictement positif.
| Anneau (A,+,*) =1 < +, 0, -, *, x-->Nx, x-->xn § N∈ℤ, n∈⓵ > |
| Anneau commutatif (A,+,*) =1 < +, 0, -, *, x-->Nx, x-->xn § N∈ℤ, n∈⓵ > |
La définition logique est :
| Anneau commutatif (A,+,*) = < +, 0, -, * > |
Anneau commutatif (A,+,*) <=> {Groupe commutatif (A,+), Semi-groupe commutatif(A,*), x*(a+b) = x*a + x*b, (a+b)*x = a*x + b*x}
|
Lorsque le semi-groupe (A,*) possède un élément neutre, alors il constitue un monoïde et cet élément est noté 1, et l'anneau (A,+,*) est dit unitaire, et cet élément 1 est appellé l'unité. Le langage s'est ainsi enrichie d'un élément neutre pour l'opération * et qui va servir d'unité notée 1 ou plus explicitement 1A lorsque plusieurs structures possédant un tel élément singulier sont en présence. La structure unitaire est déclarée par l'expression formelle Anneau unitaire (A,+,*).
L'unité enrichie le langage d'un grand nombre de noms d'élément en introduisant les répétitions additives de l'unité, qui seront symbolisées par les nombres entiers relatifs ...-3, -2, -1, 0, 1, 2, 3... et, plus explicitement, indicés par le nom de la structure au cas où il y aurait plusieurs structures possédant de tels éléments singuliers en présence ...(-3)A, (-2)A, (-1)A, 0A, 1A, 2A, 3A... Mais pour éviter d'alourdire la notation, on peut choisir un code couleur, le noir étant réservé aux entiers et le bleu étant réservé aux élèments de la structure. Ainsi nous avons :
-3 = -3(1) = (-1) + (-1) + (-1)
-2 = -2(1) = (-1) + (-1)
-1 = -1(1) = -1
0 = 0(1) = 0
1 = 1(1) = 1
2 = 2(1) = 1 + 1
3 = 3(1) = 1 + 1 + 1L'anneau unitaire (A,+,*) déclare le langage de niveau 1 comprenant l'opération +, l'élément nul 0, la fonction unaire opposé -, la soustraction -. l'opération *, les répétitions additives x-->Nx où N est un entier relatif, et les répétitions multiplicatives x-->xn où n est un entier strictement positif, et on y ajoute les répétitions additives de l'unité, N, où N est un entiers relatifs, et qui couvre le 0 et le 1.
| Anneau unitaire (A,+,*) =1 < +, -, *, N, x-->Nx, x-->xn § N∈ℤ, n∈⓵ > |
La définition logique de l'anneau unitaire (A,+,*) est :
| Anneau unitaire (A,+,*) = < +, 0, -, *, 1 > |
| Anneau unitaire (A,+,*) <=> {Groupe commutatif (A,+), Monoïde (A,*), x*(a+b) = x*a + x*b, (a+b)*x = a*x + b*x} |
Le langage de l'anneau unitaire est plus riche mais chaque appellation d'élément ne désigne pas forcement un élément distinct. La répétition additive Nx correspond au produit par l'élément N .Autrement dit la fonction x-->Nx est identique à la fonction x-->N*x. Nous avons :
N = N1
N = 1 + 1 + 1 +... N fois....Nx = N * x
Nx = x * NNn = N*n = n*N
où n et N sont des entiers relatifs. On en déduit que les éléments engendrés par l'unité et les opérateurs du langage de base de l'anneau correspondent aux entiers relatifs avec les règles d'addition et de multiplication habituelles.
Avec l'unité qui apporte ici de façon contingente la brique élémentaire, le langage de l'anneau va pouvoir engendrer une structure minimale regroupant tous les éléments définissables par des termes clos du langage en question. C'est la cloture par composition close. On renoue ainsi avec la notation intuitionniste des structures, qui prédispose d'abord les éléments et opérateurs générateurs avant de prédisposer de l'ensemble sous-jacent.qui en est limité à la cloture.
Nombreux seront les langages de niveaux supérieurs qui n'apporteront pas d'éléments supplémentaires à la cloture du langage de niveau zéro. La notation intuitionniste nomme préalablement tous les opérateurs singuliers générateurs. Ainsi la structure Anneau unitaire (+, 0, -, *, 1) désigne la structure libre engendrée par ces 5 opérateurs obéïssant à la théorie de l'anneau unitaire. C'est à dire en notation linguistique, en utilisant une opération symétrique unaire x-->-x :
<+, 0, -, *, 1> / {
(x+y)+z = x+(y+z),
x+y = y+x,
x+0 = x,
x+(-x) = 0,
(x*y)*z = x*(y*z),
x*1 = x,
1*x = x,
x*(a+b) = x*a + x*b,
(a+b)*x = a*x + b*x
}où en utilisant une oppération symétrique binaire (x,y)-->x-y :
<+, 0, -, *, 1> / {
(x+y)+z = x+(y+z),
x+y = y+x,
x+0 = x,
x-y = x+(-y),
x-x = 0,
(x*y)*z = x*(y*z),
x*1 = x,
1*x = x,
x*(a+b) = x*a + x*b,
(a+b)*x = a*x + b*x
}Ce langage engendrent par cloture, un ensemble d'éléments qui correspond exactement à l'anneau des entiers relatifs avec les règles d'addition et de multiplication habituelles. Cette sous-srtructure est appellé le centre de l'anneau.
Lorsque l'anneau est commutatif et unitaire on annonce d'abord la commutativité qui est jugée plus importante. La structure commutative unitaire est déclarée par l'expression suivante Anneau commutatif unitaire (A,+,*).
| Anneau commutatif unitaire (A,+,*) = < +, 0, -, *, 1 > |
Anneau commutatif unitaire (A,+,*) <=> {Groupe commutatif (A,+), Monoïde commutatif(A,*), x*(a+b) = x*a + x*b, (a+b)*x = a*x + b*x}
|
6) Corps
La structure de corps désigne un anneau ou chaque éléments non nul admet un inverse.
(K,+,*) est un corps si et seulement si :
(K,+,*) est un anneau Anneau (K,+,*) (K-{0},*) est un groupe Groupe (K-{0},*) (K,+,*) est un corps si et seulement si :
(K,+) est un groupe commutatif Groupe commutatif (K,+) (K-{0},*) est un groupe Groupe (K-{0},*) * est distributive par rapport à + ∀x∈K ∀a∈K ∀b∈K x*(a+b) = x*a + x*b
∀x∈K ∀a∈K ∀b∈K (a+b)*x = a*x + b*x.(K,+,*) est un corps si et seulement si :
(K,+,*) est un anneau unitaire Anneau unitaire (K,+,*) Il existe une opération unaire interne à K-{0}singulière notée (x-->1/x) ∀x∈K-{0} s(x)∈K-{0} Chaque élément x de K-{0} admet un symétrique s(x) dans K-{0} ∀x∈K x*(1/x) = 1
∀x∈K (1/x)*x = 1(K,+,*) est un corps si et seulement si :
(K,+,*) est un anneau unitaire Anneau unitaire (K,+,*) Il existe une opération binaire de (K,K-{0}) sur K singulière notée / ∀x∈K ∀y∈K-{0} x/y∈K / est l'inverse de * L'opération binaire / étend l'opération unaire x-->1/x ∀x∈K ∀y∈K-{0} x/y = x*(1/y) Chaque élément non nul x admet un symétrique 1/x ∀x∈K-{0} x/x = 1
∀x∈K-{0} (1/x)*x = 1La structure est déclarée par l'expression formelle Corps (K,+,*). Le premier terme K désigne l'ensemble sous-jacent regroupant tous les élements du corps. Le second terme + désigne l'addition interne au corps, le troisième terme * désigne la multilication interne au corps. La structure de corps affirme qu'il existe un élément singulier noté 0, qu'il existe une fonction unaire interne notée -, qu'il existe un élément singulier noté 1, et qu'il existe une foncion unaire interne inverse notée (x-->1/x). On définie aussi l'opération binaire - par l'égalité x-y = x+(-y) et l'opération binaire / par l'égalité x/y = x*(1/y).
| Corps (K,+,*) = < +, 0, -, *, 1, / > |
| Corps (K,+,*) <=> {Anneau (K,+,*), Groupe (K-{0},*)} |
| Corps (K,+,*) <=> {Groupe commutatif (K,+), Groupe (K-{0},*), x*(a+b) = x*a + x*b, (a+b)*x = a*x + b*x.} |
| Corps (K,+,*) <=> {Anneau unitaire (K,+,*) , x*(1/x) = 1, (1/x)*x = 1} |
| Corps (K,+,*) <=> {Anneau unitaire (K,+,*) , x/y = x*(1/y), x/x = 1, (1/x)*x = 1} |
0 est l'élément nul du corps.
1 est l'élément unité du corps.
On note K* l'ensemble K dans lequel on a enlevé l'élément nul.K* = K-{0}
Le langage est enrichi avec les répétitions, c'est à dire on considère les multiples entiers Nx et les puissances non nuls entières xN où N est un entier relatif. Par exemples :
-3x = (-x)+(-x)+(-x)
-2x = (-x)+(-x)
-1x = -x
0x = 0
1x = x
2x = x+x
3x = x+x+xx-3 = x
x-2 = x
x-1 = x
x0 = 1
x1 = x
x2 = x*x
x3 = x*x*xNoter que 00 n'est pas définie.
Ainsi la structure Corps (A,+,*) déclare un langage de niveau 1 comprenant l'addition +, la soustraction -, l'élément nul 0, le produit *, la division /, les éléments N, les répétitions additives x-->Nx où N est un entier relatif, et les répétitions multiplicatives x-->xn où n est un entier relatif non nul.
| Corps (K,+,*) =1 < +, -, *, /, p/q, x-->px, x-->xq § p ∈ℤ, q∈ℤ*> |
Et on considère les répétitions additives de l'unité ...-3,-2,-1,0,1,2,3... qui peuvent subire alors à leur tour les répétitions multiplicatives, ce qui produit les éléments d'appellation Nn où N est un entier relatif non nul et où n est un entier relatif, et celle-ci se résolvent
La distributivité de * sur + entraine que l'élément nul est absorbant :
∀x∈A x*0 = 0*x = 0
Lorsque le groupe (A,*) est commutatif, c'est à dire lorsque ∀x∈A ∀y∈A x*y = y*x, le corps (A,+,*) est dit commutatif, mais on garde la notation multiplicative puisque la notation additive est déjà utilisée par la première opération. La structure commutative est déclarée par l'expression formelle Corps commutatif (A,+,*). Elle définie un même langage, en notation additive pour la première opération et en notation multiplicative pour la seconde opération, qui comprend l'addition +, la soustraction -, la multiplication *, la division /, puis les éléments N et les éléments nN, les fonctions unaires x-->Nx où N est un entiers relatif, et les fonctions unaires x-->xn où n est un entier relatif non nul.
| Corps commutatif (K,+,*) = < +, 0, -, *, 1, / > |
| Corps commutatif (K,+,*) =1 < +, -, *, /, N, nN, N/n, N/n, x-->Nx, x-->xn § N∈ℤ, n∈ℤ*> |
| Corps commutatif (K,+,*) <=> {Anneau (K,+,*), Groupe (K-{0},*)} |
| Corps commutatif (K,+,*) <=> {Groupe commutatif (K,+), Groupe (K-{0},*), x*(a+b) = x*a + x*b, (a+b)*x = a*x + b*x.} |
| Corps commutatif (K,+,*) <=> {Anneau unitaire (K,+,*) , x*(1/x) = 1, (1/x)*x = 1} |
| Corps commutatif (K,+,*) <=> {Anneau unitaire (K,+,*) , x/y = x*(1/y), x/x = 1, (1/x)*x = 1} |
Avec l'unité qui apporte ici de façon contingente la brique élémentaire, le langage de l'anneau va pouvoir engendrer une structure minimale regroupant tous les éléments définissables par des termes clos du langage en question. C'est la cloture par composition close. On renoue ainsi avec la notation intuitionniste des structures, qui prédispose d'abord les éléments et opérateurs générateurs avant de prédisposé de l'ensemble sous-jacent.qui en est que la cloture.
Les langages de niveau supérieur à zéro n'apporte pas d'éléments supplémentaires à la cloture du langage de niveau zéro. La notation intuitionniste nomme préalablement tous les opérateurs singuliers générateurs. Ainsi la structure Anneau unitaire (+, 0, -, *, 1) désigne la structure libre engendrée par ces 5 opérateurs obéïssant à la théorie de l'anneau unitaire. C'est à dire en notation linguistique, en utilisant une opération symétrique unaire x-->-x :
<+, 0, -, *, 1> / {
(x+y)+z = x+(y+z),
x+y = y+x,
x+0 = x,
x+(-x) = 0,
(x*y)*z = x*(y*z),
x*1 = x,
1*x = x,
x*(a+b) = x*a + x*b,
(a+b)*x = a*x + b*x
}où en utilisant une oppération symétrique binaire (x,y)-->x-y :
<+, 0, -, *, 1> / {
(x+y)+z = x+(y+z),
x+y = y+x,
x+0 = x,
x-y = x+(-y),
x-x = 0,
(x*y)*z = x*(y*z),
x*1 = x,
1*x = x,
x*(a+b) = x*a + x*b,
(a+b)*x = a*x + b*x
}
.
6) Les extentions de corps R<C<H
Le corps des réels noté R, s'étend en le corps des complexes noté C, puis s'étend en le corps des quaternions noté H. Le corps C est algébriquement clos, c'est à dire que tout polynôme à coéfficient dans C admet au moins une racines dans C. Et dans le corps H, tout polynôme à coéfficient reel admet au moins une infinité de racines dans H.
.
---- 24 mai 2014 ----
.
.
7) K-espace vectoriel
La structure d'espace vectorielle désigne deux opérations qui sont l'addition de vecteur et la multiplication par un scalaire élément du corps K. Le corps K habituellement utilisé est celui des réels mais ce n'est pas une obligation, parcontre le corps K doit être commutatif. Les éléments de E sont appelé vecteur, et les éléments de K sont appelé scalaire. L'addition vectorielle doit être interne, associative, commutative, avec un élément neutre, et tel que chaque vecteur admet un symétrique. La multiplication doit vérifier la distributivité par rapport aux scalaires (a + b)*V = a*V + b*V, la distributivité par rapport aux vecteurs a*(U + V) = a*U + a*V, l'associativité pour les scalaires a*(b*V) = (a*b)*V, et la neutralité pour l'élément unité de K, 1K*V = V. La structure complètes (E,+,*,(K,+,*)) d'espace vectoriel E sur un corps K, comprend deux ensembles sous jacent que sont l'ensembles des vecteurs E et l'ensemble des scalaires K, et 4 opérations que sont ; l'addition et la multiplication dans le corps K, l'addition de deux vecteurs de E et la multiplicaétion d'un scalaire de K par un vecteur de E.
E est un K-espace vectoriel ssi :
(E,+) est un groupe commutatif
On note 0E l'élément neutre de l'opération +, appelé le vecteur nul de E.
(K,+,*) est un corps commutatif.
On fait opérer K sur E en définisant une opération * de KxE sur E.
On note a,b deux éléments quelconques de K et v un élément quelconque de E.
Distributivité par rapport aux scalaires : (a + b)*V = a*V + b*V.
Distributivité par rapport aux vecteurs : a*(U + V) = a*U + a*V.
Associativité pour les produits par scalaires : a*(b*V) = (a*b)*V.
Neutralité pour l'élément unité de K, 1K*V = V.On note k un élément quelconque de K. Par simplicité on note indifféremment k*V = V*k, ou plus exactement on fait opérer K sur E de la même façon à droite et à gauche. On pourrait faire agire K sur E plusieurs fois de façon différente avec plusieur opération * différentes. Dans ce cas E constituerait l'ensemble sous-jasent commun de plusieurs structures de K-espace vectorielle.
5) Les applications
Précisément une application possède un ensemble de départ et un ensemble d'arrivé noté f : A-->B, et f est définie en tout point de A, c'est à dire que le domaine de définition de f couvre l'ensemble A. Lorsque f(x) = y, y est appelé l'image de x par f, et x est appelé un antécédent de y par f. Soit E un ensemble. Par abus de langage, on note f(E), l'ensemble des images des éléments de E, appelé aussi image de E par f. Et on note f^(-1)(E) l'ensemble des éventuels antécédents de E, appelé aussi antécédent de E par f.
Une application f : A-->B est bijective ssi il existe une application inverse g : B --> A tel que pour tout élément a de A on ait g(f(a)) = a et pour tout élément b de B on ait f(g(b)) = b. La bijectivité est équivalente à deux propriétés que sont la surjection et l'injection. La surjection est l'assurence que pour tout élément de l'ensemble d'arrivé qu'il existe au moins un antécédent, l'injection est l'assurence que pour tout élément de l'ensemble d'arrivé il existe au plus un antécédent. f est surjective lorsque tous les éléments de B sont atteint par l'application f. Et f est injective lorsque si x différent de y alors f(x) est différent de f(y), ce qui par contraposé signifie, si f(x)=f(y) alors x=y. En d'autre terme la surjectivité signifie que l'image f(A) = B, et l'injectivité signifie que les noyaux f^(-1)({z}) sont soit vides ou sont des singletons (c.a.d. quelque soit z élément de B, il y a un ou zéro antécédent de z par f).
6) Les isomorphismes
On appel isomorphisme une application bijective entre deux mêmes structures qui respecte les opérations de la structure.
Soit deux groupes (A,*) et (B,*), l'application f : A-->B est un isomorphisme ssi l'application f respecte l'opération * dans A et B c'est à dire si quelque soit x,y deux éléments de A nous avons f(x*y) = f(x)*f(y), et si f est bijective c'est à dire que l'image f(A) = B et, en utilisant la rigidité de la structure, que le noyaux f^(-1)({1B}) est égale au singleton {1A}.
Soit deux corps (G,+,*) et (K,+,*), l'application f : G-->K est un isomorphisme ssi l'aplication f respecte les opérations + et * dans G et K c'est à dire si quelque soit x,y deux éléments de A nous avons f(x + y) = f(x) + f(y) et f(x*y) = f(x)*f(y), et si f est bijective c'est à dire surjective, f(G)=K, et injective, le noyaux f^(-1)({0K}) est égale au singleton {0G}.
Soit deux K-espaces vectoriels (E,+,*,(K,+,*)) et (F,+,*,(K,+,*)), l'application f : E-->F est un isomorphisme ssi l'aplication f respecte les opérations + et * dans E et F c'est à dire si f(x + y) = f(x) + f(y) et f(k*x) = k*f(x) où x, y sont des vecteurs quelconques de E et k un scalaire quelconque de K, et si f est bijective, c'est à dire surjective, f(E)=F, et injective, le noyaux f^(-1)({0F}) est égale au singleton {0E}.
Lorsque qu'il existe un isomorphisme entre deux structures, les structures sont dites isomorphes. Elle peuvent être identifiées l'une à l'autre. Les structures sont identiques mais utilisent des ensembles sous-jacents différents.
7) Les plongements
On appel plongement une application injective entre deux structures qui respecte les opérations de la structure de départ en associant à chacune d'elles, une opération dans la structure image. Par exeemple, soit une application f : (A,+,*)-->(B,°,∇,?). f est un plongement si et seulement si f respecte les opérations sur A en leur associant à chacune d'elles une opération de la structure B et si f est injective c'est à dire que ∀x∈A, ∀y∈A, f (x) = f(y) => x = y. La signature du plongement est constituée par le choix des opérateurs associés du plongement. Par exemple en choisissant d'associer + à ? et * à °, la condistion de respect des opérarions consiste en ∀x∈A, ∀y∈A, f(x+y) = f(x) ? f(y) et f(x*y) = f(x) ° f(y).
Le plongement est presque un isomorphisme, il ne manque que la propriété de surjection qui est obtenue en restreingnant f sur son ensemble d'arrivé. f est un isomorphisme entre A et son image f(A). f(A) est inclu dans B. f(A) est une structure munie des opérations définies sur B. f(A) est une sous-structure de B. Lorsque une structures se plonge dans une autre, elle est isomorphe à une sous-structure incluse dans l'autre, et donc elle peut être identifiées à une sous-structure incluse dans l'autre. On parle de morphisme injectif, ou d'inclusion morphique.
8) La notion de produit direct et de somme directe
Etant donné deux groupes (A,*) et (B,*) on peut définire le groupe produit direct (A,*)×(C,*) que l'on note (A×B,*), qui est composé des couples d'éléments (a,b) de A×B, muni de l'opération * suivante : (a,b)*(c,d) = (a*b,c*d).
Etant donner deux K-espaces vectoriels A et B, on peut définire l'espace vectoriel somme directe A+B, qui est composé des couples de vecteur (a,b) de A×B, muni de l'opération + suivante : (a,b)+(c,d) = (a+b,c+d), et de l'opération * suivante : k*(a,b) = (k*a,k*b), où k désigne un éléments quelconque du corps K.
L'opération inverse consiste à décomposer un groupe en produit directe de groupes, ou un espace vectoriel en somme directe d'espaces vectoriels.
---- 9 Décembre 2012 ----
On appel produit direct une décomposition en un produit. Le produit directe G = A×B est un produit ayant la propriété supplémentaire : Quelque soit a1, a2 éléments de A et b1, b2 éléments de B, si a1 * b1 = a2 * b2 alors a1 = a2 et b1 = b2. C'est la contraposé de l'unicité. Cela signifie que tout éléments de G se décompose de façon unique en un couple d'éléments de A et B. L'application qui transforme g en sa décomposition (a,b) tel que g = a*b est un isomorphisme de groupe. Lorsque cette propriété est vérifiée, (G,*) est isomorphe à (A,*)x(B,*), ou plus simplement on dit que G est isomorphe à AxB.
De même en notations aditives (réservées aux opérations commutatives), on définie la somme directe comme une décomposition en une somme unique. La somme directe G = A + B est une somme ayant la propriété supplémentaire suivante : Quelque soit a1, a2 éléments de A et b1, b2 éléments de B, si a1 + b1 = a2 + b2 alors a1 = a2 et b1 = b2. L'existence et l'unicité de la décomposition entraine que G est isomorphe à AxB.
Dans la généralité, on applique à chaque composante des transformations isomorphes notées ici φ1, φ2, φ3, la décomposition en somme directe de G, s'écrit G = φ1(A) + φ2(B) + φ3(C). Chaque éléments g de G se décompose de façon unique en un triplet (a,b,c) de AxBxC telque g = φ1(a) + φ2(b) + φ3(c). L'existence et l'unicité permet d'établir l'isomorphisme entre G et AxBxC. Cette exemple est généralisable à une sommes directe de n termes.
Deux sous-espaces vecoriels sont dits disjoints lorsque aucun d'eux n'est réduit au seul vecteur nul, et que parcontre leur intersection est réduite au seul vecteur nul. Soit A,B,C, des sous-espaces vectoriels, le sous-espace vectoriel engendré par A,B,C est A+B+C. Soit trois vecteurs u,v,w, le sous-espace vectoriel engendré par u,v,w est K*u + K*v + K*w où K est le corps sur lequel l'espace vectoriel est défini. Un ensemble de sous-espaces vectoriels est dit libre, ou sont dits indépendants, ssi chaque sous-espace est disjoint de l'espace engendré par les autres. Un ensemble de vecteurs, est dit libre, ou sont dits indépendants, ssi chaque vecteur est en dehors de l'espace engendré par les autres.
10) Les sous espace vectoriels
Un ensemble de sous epaces vectorielles A1, A2, A3... de E est dit indépendant et générateur lorsque la somme E = A1 + A2 + A3... est une somme directe. L'unicité de la décomposition en cette somme traduit l'indépendance des sous espaces vectoriels, et l'existence de cette décomposition traduit le caractère générateur. L'unicité et l'existence de la somme directe dévoile un isomorphisme. A chaque vecteur e il existe un unique n-uplet(a1,a2,a3...) appartenant à A1xA2xA3x... telque e = a1 + a2 + a3.... La dimension de E est égale à la somme des dimensions des sous-espaces vectoriel A1, A2, A3.... Le n-uplet de vecteurs (a1,a2,a3...) constitue les composantes du vecteur e selon cette somme directe. L'ensemble A1xA2xA3x...munie de l'addition suivante : (a1,a2,a3...) + (b1,b2,b3...) = (a1 + b1, a2 + b2, a3 + b3...) et de la multiplication par un scalaire suivante : k*(a1,a2,a3...) = (k*a1, k*a2, k*a3...) constitue un K-espace vectoriel isomorphe à E selon cette somme directe.
11) Théorème de Frobenius sur les dimenssions maximales 2 et 4.
Si un corps commutatif contient, le corps des réel R, alors il possède une structure d'espace vectoriel sur R. Et si cet espace est de dimenssion finie, alors il ne peut s'agire que de R ou du corps des complexes C (dimenssion égale à 1 ou 2) et il n'y a pas d'autre corps possible (à isomorphisme près, bien entendu). Si un corps non commutatif contient dans son centre (le centre est l'ensemble des éléments qui commutent avec tous les éléments) le corps des réels R, alors il possède une structure d'espace vectoriel sur R. Et si cette espace est de dimenssion finie, alors ce corps ne peut être que le corps des quaternions H (dimenssion égale à 4). La démonstration du théorème passe en revue les différents groupes multiplicatifs possibles des vecteurs unités d'un corps possédant une structure de R-espace vectoriel.
Une forme linéaire définie sur E, est une application linéaire f de l'espace vectoriel E vers son corps K. La propriété de linéarité signifie que quelque soit un scalaire a élément de K, et des vecteurs u, v éléments de E, nous avons :
f(u + v) = f(u) + f(v)
f(a*v) = a* f(v).L'ensemble des formes linéaires définie sur E peut être munie de l'addition et de la multiplication suivante :
(f + g)(u) = f(u) + g(u)
(a*f)(u) = a*f(u)Il constitue un K-espace vectoriel appelé espace dual, noté E'. Lorsque E est de dimenssion finie, E et E' ont même dimenssion.
14) l'espace dual de l'espace dual
Les formes linéaires définies sur E' constituent l'espace dual de l'espace dual de E que l'on note E''. Il existe un isomophisme canonique envoyant E sur E''. On note v'' l'image d'un vecteur v par cette isomophisme canonique. Cette isomorphisme v --> v'' est défini par la formule suivante :
v''(f) = f(v) quelque soit f élément de E'
L'espace dual de l'espace dual, noté E'', peut s'identifier à l'espace E de cette façon. A chaque vecteur v de E correspond un élément v'' de E'', qui est une forme linéaire définie sur E' comme suit : Elle envoie toute forme linéaire f définie sur E, en l'image de v par f .
On définie le produit scalaires sur E'xE, <f,v> = f(v). C'est une application bilinéaire de E'xE vers K. C'est la composition d'une forme linéaire avec un vecteur. Ce produit scalaire est défini indépendament du choix d'une base. Il est noté sous forme d'un produit qui correspondra au produit matriciel : f*v = <f,v> = f(v).
La bilinéarité du produit scalaire signifie que pour tout scalaire a,b, tout vecteur u,v et toute forme linéaire f,g, nous avons les relations suivantes (avec les trois écritures possibles) :
(f + g)(u + v) = f(u) + f(v) + g(u) + g(v)
(a*f)(b*u) = a*b*f(u)<f + g, u + v> = <f,u> + <f,v> + <g,u> + <g,v>
<a*f, b*u> = a*b*<f,u>(f + g)*(u + v) = f*u + f*v + g*u + g*v
a*f*b*u = a*b*f*u16) Les bases et les bases duales
Les sous-espaces vectoriels de dimenssion 1 sont de la forme K*e où e est un vecteur non nul. Les espaces vectoriels de dimenssion 3 se mettent sous la forme d'une somme directe K*e1 + K*e2 + K*e3 où (e1,e2,e3) sont des vecteurs indépendants constituant ainsi une base. On se place dans un espace de dimenssion 3 pour l'exemple, mais cela se généralise pour un espace de dimenssion n.
Un vecteur est de la forme v = v1*e1 + v2*e2 + v3*e3 où (v1,v2,v3), élément de K^3, sont les coordonnées de v relatives à la base (e1,e2,e3). Une forme linéaire f est entièrement définie par l'image d'une base, ainsi la connaissance des trois scalaires f(e1), f(e2), f(e3) détermine exactement f. En effet, en développant v, et en utilisant la propriété de linéarité de f du §12, nous obtenons f(v) = v1*f(e1) + v2*f(e2) + v3*f(e3).
A partir d'une base (e1,e2,e3) de E, on définie canoniquement une base duale (e1',e2',e3') qui constitue une base de E', de la façon suivante (ici exprimé avec les trois écritures possibles) :
e1'(e1)=1, e1'(e2)=0, e1'(e3)=0
e2'(e1)=0, e2'(e2)=1, e2'(e3)=0
e3'(e1)=0, e3'(e2)=0, e3'(e3)=1<e1',e1>=1, <e1',e2>=0, <e1',e3>=0
<e2',e1>=0, <e2',e2>=1, <e2',e3>=0
<e3',e1>=0, <e3',e2>=0, <e3',e3>=1e1'*e1=1, e1'*e2=0, e1'*e3=0
e2'*e1=0, e2'*e2=1, e2'*e3=0
e3'*e1=0, e3'*e2=0, e3'*e3=1Soit un vecteur v de composante (v1,v2,v3) dans la base (e1,e2,e3). Nous avons :
v = v1*e1 + v2*e2 + v3*e3
e1'(v) = v1*e1'(e1) + v2*e1'(e2) + v3*e1'(e3) = v1
e2'(v) = v1*e2'(e1) + v2*e2'(e2) + v3*e2'(e3) = v2
e3'(v) = v1*e3'(e1) + v2*e3'(e2) + v3*e3'(e3) = v3e1' est la forme linéaire qui transforme v en sa composante v1 relativement à la base (e1,e2,e3). De même e2' transforme v en sa composante v2 relativement à la base (e1,e2,e3), et e3' transforme v en sa composante v3 relativement à la base (e1,e2,e3). Ceux sont les projections relatives à la base (e1,e2,e3).
Une forme linéaire f se présente comme suit : f = f1*e1' + f2*e2' + f3*e3' où (f1,f2,f3), élément de K^3, sont les coordonnées de f relatives à la base (e1',e2',e3'). On définie canoniquement la base duale de la base duale (e1'',e2'',e3'') qui constitue une base de E'', par le même procédé :
e1"(e1')=1, e1"(e2')=0, e1"(e3')=0
e2"(e1')=0, e2"(e2')=1, e2"(e3')=0
e3"(e1')=0, e3"(e2')=0, e3"(e3')=1e1'' est la forme linéaire qui transforme f en sa composante f1 relativement à la base (e1',e2',e3'). De même e2'' transforme f en sa composante f2 relativement à la base (e1',e2',e3'), et e3'' transforme f en sa composante f3 relativement à la base (e1',e2',e3'). La définition de la base dual de la base dual coïncide avec l'isomorphisme canonique entre E et E''. Nous avons les relations de projection suivantes :
e1"(f) = f(e1) = f1
e2"(f) = f(e2) = f2
e3"(f) = f(e3) = f3Il est à noter que ces relations sont indépendantes du choix de la base (e1,e2,e3) puisque elles se déduisent de l'isomorphisme canonique entre E et E''. Soit v un vecteur de E et f une forme linéaire définie sur E.
v = v1*e1 + v2*e2 + v3*e3
f = f1*e1' + f2*e2' + f3*e3'En faisant opérer la base duale (e1',e2',e3') sur v, et la base duale de la base duale (e1'',e2'',e3'') sur f, nous obtenons les projections suivantes (ici écrites avec les trois écritures possibles) :
|
e1'(v)
= v1 |
<e1',v> = v1 |
e1'*v
= v1 |
|
e1"(f) =
f(e1) = f1 |
<e1",f> = <f,e1> =
f1 |
e1"*f =
f*e1 = f1 |
e1'' est une forme linéaire définie sur E' qui ne dépend que du seul vecteur e1 (définie par la relation e1''(f) = f(e1) quelque soit f), alors que e1' est une forme linéaire définie sur E qui ne dépend pas seulement de e1, mais également de e2 et de e3.
Les liens canoniques découverts sont ; l'isomorphisme entre E sur E'' transformant tout vecteur v en v'' (où v''(f) = f(v) quelque soit f), et la bijection entre les bases de E et les bases de E', qui transforme une base (e1,e2,e3) de E en une base (e1',e2',e3') de E' définie par e1'*e1=1, e1'*e2=0, e1'*e3=0, e2'*e1=0, e2'*e2=1, e2'*e3=0, e3'*e1=0, e3'*e2=0, e3'*e3=1.
Une même bijection canonique transforme une base (e1',e2',e3') de E' en une base de (e1'',e2'',e3'') de E'' définie de la même manière par e1''*e1'=1, e1''*e2'=0, e1''*e3'=0, e2''*e1'=0, e2''*e2'=1, e2''*e3'=0, e3''*e1'=0, e3''*e2'=0, e3''*e3'=1.
Le fait important de concordance, qui justifie l'usage de ces outils, est que la base dual de la base duale s'obtient à partir de la base en appliquant à chacun de ses vecteurs, l'isomorphisme canonique entre E sur E''.
Développons f(v) en développant f (avec les trois écritures possibles) :
f(v) = (f1*e1' + f2*e2' + f3*e3')(v)
f(v) = f1*e1'(v) + f2*e2'(v) + f3*e3'(v)
f(v) = f1*v1 + f2*v2 + f3*v3<f,v> = <f1*e1' + f2*e2' + f3*e3', v>
<f,v> = f1*<e1',v> + f2*<e2',v> + f3*<e3',v>
<f,v> = f1*v1 + f2*v2 + f3*v3f*v = (f1*e1' + f2*e2' + f3*e3')*v
f*v = f1*e1'*v + f2*e2'*v + f3*e3'*v
f*v = f1*v1 + f2*v2 + f3*v3Noter que l'opération * représente plusieurs opérations, qui peuvent chacune être définie comme une application bilinéaire parmis : KxE->E, KxE'->E', E'xE->K, E''xE'->K. Le contexte, c'est à dire le typage des opérandes, permet de déterminer laquel des opérations est évoquées.
17) Les changements de base et les automorphismes
Un automorphisme A de E est une application linéaire inversible de E dans E. La propriété de linéarité signifie que quelque soit un scalaire a élément de K, et des vecteurs u, v éléments de E, nous avons :
A(u + v) = A(u) + A(v)
A(a*v) = a* A(v).La différence entre les applications linéaires et les formes linéaires réside dans l'ensemble d'arrivé qui est un espace vectoriel. Un automorphisme est complètement caractèrisé par l'image d'une base qui constitue une autre base. L'automorphisme A qui transforme les trois vecteurs de base (e1,e2,e3) en les trois vecteurs de base (ee1,ee2,ee3) se calcule simplement en développant les vecteurs selon la base de départ (e1,e2,e3).
A(e1) = ee1
A(e2) = ee2
A(e3) = ee3Soit un vecteur v de composante (v1,v2,v3) dans la base (e1,e2,e3), et de composante (vv1,vv2,vv3) dans la base (ee1,ee2,ee3) :
v = v1*e1 + v2*e2 + v3*e3
v1 = e1'*v
v2 = e2'*v
v3 = e3'*v
v = vv1*ee1 + vv2*ee2 + vv3*ee3vv1 = ee1'*v
vv2 = ee2'*v
vv3 = ee3'*vEn développant v selon la base (e1,e2,e3) on obtient :
A(v) = A(v1*e1 + v2*e2 + v3*e3)
A(v) = v1*A(e1) + v2*A(e2) + v3*A(e3)
A(v) = v1*ee1 + v2*ee2 + v3*ee3L'automorphisme inverse A^(-1) qui transforme les trois vecteurs de base (ee1,ee2,ee3) en (e1,e2,e3) s'obtient en développant v selon la base (ee1,ee2,ee3) :
A^(-1)(v) = A^(-1)(vv1*ee1 + vv2*ee2 + vv3*ee3)
A^(-1)(v) = vv1*A^(-1)(ee1) + vv2*A^(-1)(ee2) + vv3*A^(-1)(ee3)
A^(-1)(v) = vv1*e1 + vv2*e2 + vv3*e3La transformation des coordonnées de v, (v1,v2,v3) en (vv1,vv2,vv3) est appelé changement de base de (e1,e2,e3) à (ee1,ee2,ee3). C'est un automorphisme de K^3 qui peut être identifiée à un automorphisme de E transformant le vecteur v de composante (v1,v2,v3) en le vecteur de composante (vv1,vv2,vv3) dans la même base (e1,e2,e3), c'est à dire transformant v = v1*e1 + v2*e2 + v3*e3 en vv1*e1 + vv2*e2 + vv3*e3 c'est à dire en A^(-1)(v). Cette automorphisme est donc A^(-1), l'automorphisme inverse, qui transforme (ee1,ee2,ee3) en (e1,e2,e3). Intuitivement le changement de base correspond à la transformation de l'espace vectoriel par l'automorphisme A, à l'exception du vecteur v, et donc correspond relativement à l'espace vectoriel transformé, à la transformation du vecteur v par l'automorphisme inverse A^(-1).
On appel la transfomation de la base (e1,e2,e3) en (ee1,ee2,ee3), l'automorphisme A telque A(e1) = ee1, A(e2) = ee2, A(e3) = ee3. Exprimons A(v). Soit un vecteur v = v1*e1 + v2*e2 + v3*e3. En décomposant v nous obtenons : A(v) = v1*A(e1) + v2*A(e2) + v3*A(e3) = v1*ee1 + v2*ee2 + v3*ee3. Et donc :
A(v) = e1'(v)*ee1 + e2'(v)*ee2 + e3'(v)*ee3.
On appel la transformation des coordonnées par changement de base (e1,e2,e3) en (ee1,ee2,ee3), l'automorphisme de K^3 qui transforme le vecteur (v1,v2,v3) en (vv1,vv2,vv3), où (vv1,vv2,vv3) sont les composantes du vecteur v = v1*e1+v2*e2+v3*e3 exprimé dans la base (ee1,ee2,ee3). C'est à dire :
vv1 = ee1'(v) = v1*ee1'(e1) + v2*ee1'(e2) + v3*ee1'(e3)
vv2 = ee2'(v) = v1*ee2'(e1) + v2*ee2'(e2) + v3*ee2'(e3)
vv3 = ee3'(v) = v1*ee3'(e1) + v2*ee3'(e2) + v3*ee3'(e3)Qui s'exprime avec le produit tensoriel par :
vv1 = ee1'*v = v1*ee1'*e1 + v2*ee1'*e2 + v3*ee1'*e3
vv2 = ee2'*v = v1*ee2'*e1 + v2*ee2'*e2 + v3*ee2'*e3
vv3 = ee3'*v = v1*ee3'*e1 + v2*ee3'*e2 + v3*ee3'*e3Son automorphisme associé B transforme les vecteurs v de composantes (v1,v2,v3) dans la base (e1,e2,e3) en le vecteur B(v) de composante (vv1,vv2,vv3) dans la base (e1,e2,e3).
B(v) = vv1*e1+vv2*e2+vv3*e3
B(v) = ee1'(v)*e1 + ee2'(v)*e2 + ee3'(v)*e3Qui s'exprime avec le produit tensoriel par :
B(v) = ee1'*v*e1 + ee2'*v*e2 + ee3'*v*e3
A et B sont l'inverse l'un de l'autre : A(B(v)) = B(A(v)) = v.
18) Les endomorphismes et le produit matriciel ou tensoriel
Un endomorphisme A de E est une application linéaire de E dans E qui n'est pas forcément inversible comme les automorphismes. Les endomorphismes de E peuvent être munie de l'addition, et de la multiplication,
(A + B)(u) = A(u) + B(u)
(k*A)(u) = k*A(u)Ils constituent un K-espace vectoriel noté End(E). L'image d'un vecteur v par un endomorphisme A s'exprime dans la base (e1,e2,e3) par : A(v) = A1(v)*e1 + A2(v)*e2 + A3(v)*e3 où A1, A2, A3 sont des formes linéaires définies sur E qui ne dépendent que de A et de la base (e1,e2,e3).
L'opération de produit matriciel peut de facon originale être définie indépendament de toute base. On l'appel dans ce cas, opération tensorielle. Elle est constituée par plusieurs opérations * qui sont chacune définie comme une application bilinéaire parmis : KxE->E, KxE'->E', E'xE->K, E''xE'->K..., le typage des opérandes, permettant de déterminer laquel des opérations * est évoquées. On définie le produit * : End(E)xE --> E pour désigner la composition d'un endomorphisme avec un vecteur. On définie le produit * : End(E)xEnd(E) --> End(E) pour désigner la composition de deux endomorphismes. On définie le produit * : ExE' --> End(E), d'un vecteur e par une forme linéaire f comme égale à l'endomorphisme transformant tout vecteur v en f(v)*e. (Ce produit est noté e*f, et non f*e qui désigner le produit scalaire.)
Le produit tensorielle est collectivement associatif. Le produit tensoriel est décrit ici comme une mutltitude d'opération *. L'associativité collective signifie qu'une expression (a*b)*c = a*(b*c) sans que les opérations *, faisant parties du produit tensoriel, soient les mêmes. Par exemple prenons une forme linéaire f, un endomorphisme A est un vecteur v. Nous avons (f*A)*v = f*(A*v) noté abusivement f*A*v (car dans cette expression sans parenthèse, nous ne pouvons pas déterminé de façon unique le rôle de chaque opération *)
Les endomorphismes de E se décomposent en la somme directe End(E) = e1*E' + e2*E' + e3*E'. Et A1, A2, A3 sont les composantes de A exprimées selon cette somme directe. A l'aide de la base (e1',e2',e3') de E', on construit une base de End(E) qui est : (e1*e1', e1*e2', e1*e3', e2*e1', e2*e2', e2*e3', e3*e1', e3*e2', e3*e3'), qui correspond à la somme directe suivante : End(E) = K*e1*e1' + K*e1*e2' + K*e1*e3' + K*e2*e1' + K*e2*e2' + K*e2*e3' + K*e3*e1' + K*e3*e2' + K*e3*e3'
Dans l'espace vectoriel End(E) et d'après la somme directe End(E) = e1*E' + e2*E' + e3*E', nous avons l'égalité :
A = e1*A1 + e2*A2 + e3*A3
D'autre part :
A(v) = A1(v)*e1 + A2(v)*e2 + A3(v)*e3
A1(v) = e1'(A(v))
A2(v) = e2'(A(v))
A3(v) = e3'(A(v))A1 = e1' ° A
A2 = e2' ° A
A3 = e3' ° Aoù ° désigne l'opération de composition d'application, composition d'une forme linéaire avec un endomorphisme. On définie le produit * : E'xEnd(E) --> E' pour désigner la composition d'une forme avec un endomorphisme. Cette opération correspond également à une multiplication tensorielle, nous pouvons écrire :
A1 = e1'*A
A2 = e2'*A
A3 = e3'*AChaque coordonnée A1, A2, A3 est une forme linéaire qui se décompose dans la base dual (e1',e2',e3') :
A1 = A11*e1' + A12*e2' + A13*e3'
A2 = A21*e1' + A22*e2' + A23*e3'
A3 = A31*e1' + A32*e2' + A33*e3'A11 = e1"(A1) = A1(e1) = (e1' ° A)(e1)
A12 = e1"(A2) = A2(e1) = (e2' ° A)(e1)
A13 = e1"(A3) = A3(e1) = (e3' ° A)(e1)A21 = e2"(A1) = A1(e2) = (e1' ° A)(e2)
A22 = e2"(A2) = A2(e2) = (e2' ° A)(e2)
A23 = e2"(A3) = A3(e2) = (e3' ° A)(e2)A31 = e3"(A1) = A1(e3) = (e1' ° A)(e3)
A32 = e3"(A2) = A2(e3) = (e2' ° A)(e3)
A33 = e3"(A3) = A3(e3) = (e3' ° A)(e3)Cela se traduit à l'aide de l'opération * par :
A11 = e1''*A1 = A1*e1 = e1'*A*e1
A12 = e1''*A2 = A2*e1 = e2'*A*e1
A13 = e1''*A3 = A3*e1 = e3'*A*e1A21 = e2''*A1 = A1*e2 = e1'*A*e2
A22 = e2''*A2 = A2*e2 = e2'*A*e2
A23 = e2''*A3 = A3*e2 = e3'*A*e2A31 = e3''*A1 = A1*e3 = e1'*A*e3
A32 = e3''*A2 = A2*e3 = e2'*A*e3
A33 = e3''*A3 = A3*e3 = e3'*A*e3Aij désigne la j-ème composante de la forme linéaire Ai exprimée dans la base (e1',e2',e3'). Et Ai désigne la i-ème composante de l'endomorphisme A exprimé selon la somme directe End(E) = e1*E' + e2*E' + e3*E'. En d'autres termes, Aij désigne la composante en ei*ej' de l'endomorphisme A exprimé dans la base (e1*e1', e1*e2', e1*e3', e2*e1', e2*e2', e2*e3', e3*e1', e3*e2', e3*e3'). Nous avons donc l'égalité suivante dans l'espace des endomorphismes de E :
A = A11*e1*e1' + A12*e1*e2' + A13*e1*e3'
+ A21*e2*e1' + A22*e2*e2' + A23*e2*e3'
+ A31*e3*e1' + A32*e3*e2' + A33*e3*e3'Developpons A(v) en développant A :
v = v1*e1 + v2*e2 + v3*e3
A1(v) = A11*e1'(v) + A12*e2'(v) + A13*e3'(v)
A2(v) = A21*e1'(v) + A22*e2'(v) + A23*e3'(v)
A3(v) = A31*e1'(v) + A32*e2'(v) + A33*e3'(v)A1(v) = A11*v1 + A12*v2 + A13*v3
A2(v) = A21*v1 + A22*v2 + A23*v3
A3(v) = A31*v1 + A32*v2 + A33*v3.
....
Après avoir fait le choix d'une base (e1,e2,e3), on peut utiliser une notation matricielle pour exprimer les équations précédentes :
[v1] [A1]
v = [v2] A = [A2]
[v3] [A3]A1 = [A11,A12,A13] A2 = [A21,A22,A23] A3 = [A31,A32,A33]
[A11,A12,A13]
A = [A21,A22,A23]
[A31,A32,A33]A partir d'une base (e1,e2,e3) de E, nous pouvons décomposé en sommes directe, l'espace E = K*e1 + K*e2 + K*e3, l'espace des formes E' = K*e1' + K*e2' + K*e3'. L'espace des endomorphismes peut être décomposé de deux façons différentes : End(E) = e1*E' + e2*E' + e3*E', et End(E) = E*e1' + E*e2' + E*e3'. Pour l'instant considérons la première décomposition. Un endomorphisme A est représenté par une matrice colonne où chaque composantes A1, A2, A3 est un élément de E' représenté par une matrice ligne où chaque composantes est un scalaire de K. On obtient en emboitant les matrices, la matrice de l'endomorphisme A selon la base (e1,e2,e3).
[A11,A12,A13] [v1] [A11*v1 + A12*v2 + A13*v3]
A(v) = [A21,A22,A23] * [v2] = [A21*v1 + A22*v2 + A23*v3]
[A31,A32,A33] [v3] [A31*v1 + A32*v2 + A33*v3]Le produit matriciel consiste a effectuer la somme des produits croisés d'une ligne de la première matrice avec une colone de la seconde matrice et de mettre le résultat à l'intersection de la ligne et de la colone considérées dans la matrice résultat. Ci-dessus la deuxième matrice étant une matrice colonne (ne contenant qu'une seul colonne), le résultat est donc une matrice colonne.
On représente les composantes d'une matrice sous forme de variable doublement indicé Aij, où i est le numéro de ligne et j le numéro de colonne, en commençant par 1, et selon le sens de lecture à l'occidentale c'est à dire , ligne par ligne, de gauche à droite, et de haut en bas. Ce choix est arbitraire et nous pouvons représenter les matrices et leurs produits selon un autre ordre. Déja 8 possibilitées s'imposent d'elles-mêmes, l'ordre des colonnes de gauche à droite ou de droite à gauche, composé avec l'ordre des lignes de haut en bas ou de bas en haut, composé avec l'ordre de lecture colonne par colonne ou ligne par ligne, qui correspond à la permutation des indices ligne colonne soit à une transposition.
Dans le cas générale on peut multiplier une matrice de k1 lignes et n colonnes par une matrice de n lignes et k2 colonnes pour donner une matrice k1 lignes, k2 colonnes comme dans l'exemple suivant :
[a11,a12] [b11,b12,b13]
[a21,a22] * [b21,b22,b24]
[a31,a32][a11*b11 + a12*b21, a11*b12 + a12*b22, a11*b13 + a12*b23]
= [a21*b11 + a22*b21, a21*b12 + a22*b22, a21*b13 + a22*b23]
[a31*b11 + a32*b21, a31*b12 + a32*b22, a31*b13 + a32*b23]La matrice d'un vecteur peut être soit verticale ou horizontale, appelée matrice colonne ou matrice ligne. Cette qualité qui est ajouté par la notation matriciel doit être fixée arbitrairement. La représentation des vecteurs de E est fixée comme verticale, et celle des vecteurs de E' comme horizontale. Le produit scalaire est alors obtenu par le produit matriciel suivant :
[v1]
f*v = [f1,f2,f3] * [v2]
[v3]
f*v = f1*v1 + f2*v2 + f3*v3L'endomorphisme produit d'un vecteur et d'une forme linéaire est obtenue par le produit matriciel suivant :
[v1]
v*f = [v2] * [f1,f2,f3]
[v3]
[f1*v1,f2*v1,f3*v1]
v*f = [f1*v2,f2*v2,f3*v2]
[f1*v3,f2*v3,f3*v3]Attention, le produit tensoriel n'est pas en générale commutatif. Le produit f*v désigne le produit scalaire entre un forme linéaire et un vecteur, et v*f désigne l'endomorphisme produit d'un vecteur et d'une forme linéaire. Nous n'identifions pas implicitement E à E'' sinon nous ne pourrions pas distinguer v*f de f*v. Nous notons explicitement v'' l'élément de E'' associé à v, et de même nous notons f'' l'élément de E''' associé à f, et ainsi de suite.
[A11,A12,A13] [e1'*A*e1, e'1*A*e2, e'1*A*e3]
A = [A21,A22,A23] = [e2'*A*e1, e'2*A*e2, e'2*A*e3]
[A31,A32,A33] [e3'*A*e1, e'3*A*e2, e'3*A*e3]Pour i, j compris entre 1 et 3 nous avons : Aij = ei'*A*ej
L'inconvénient majeur de la notation matricielle est quel dépend implicitement du choix d'une base. La base doit être définie avant toute utilisation de la notation matricielle. C'est pourquoi on la remplace souvent par la notation tensorielle qui elle est indépendante de toutes base.
Le choix d'une base que l'on qualifie d'orthonormée, c'est à dire qui sert d'étalon de distance et d'angle droit de référence, rend l'espace euclidien. Il le muni d'une forme bilinéaire symètrique appelée également produit scalaire définissant la relation d'orthogonalité et la norme des vecteurs. Cela est identique à munir l'espace vectoriel E d'un isomorphisme vers E' que l'on note v --> v' et qui transforme tout vecteur v = v1*e1 + v2*e2 + v3*e3 en la forme linéaire v' = v1*e1' + v2*e2' + v3*e3'. Le produit scalaire de u et de v est une forme bilinéaire de ExE --> K définie par u•v = <u',v> = u'*v = u1*v1 + u2*v2 + u3*v3. La norme de u est définie par |u| = sqrt(u•u). Noter que cette définitions est dépendantes du choix de la base orthonormée (à partir de laquel on a construit l'isomorphisme entre E et E').
Une forme quadratique Q est une forme définie sur E, tel qu'il existe une forme bilinéaire B avec Q(v) = B(v,v). Cette application implicitement décrite, qui transforme les formes bilinéaires B en formes quadradiques Q, est bijective car nous avons l'application réciproque qui transforme une forme quadratique Q en une forme bilinéaire B selon la formule : B(u,v) = (Q(u + v) - Q(u) - Q(v))/2. Le carré de la norme |u|^2 = u•u est une forme quadratique.
L'espace des endomorphismes peut être décomposé de deux façons différentes : End(E) = e1*E' + e2*E' + e3*E', et End(E) = E*e1' + E*e2' + E*e3'. Nous avons commencé à développer A selon la première décomposition en somme directe : A = e1*A1 + e2*A2 + e3*A3. les composantes A1, A2, A3, éléments de E', correspondent aux lignes de la matrice A. Nous pouvons également développer A selon la seconde décomposition en somme directe : A = A(e1)*e1' + A(e2)*e2' + A(e3)*e3' selon les composantes vectoriels A(e1), A(e2), A(e3) éléments de E, correspondant aux 3 colonnes de la matrice A. Le produit matriciel est également définie sur les matrices de matrices, et il unifie ces deux types de développement :
A = e1*A1 + e2*A2 + e3*A3
A = A(e1)*e1' + A(e2)*e2' + A(e3)*e3'
A1 = e1' * A A(e1) = A * e1
A2 = e2' * A A(e2) = A * e2
A3 = e3' * A A(e3) = A * e3Les deux developpements de A se résument par :
A = e1*e1'*A + e2*e2'*A + e3*e3'*A = A*e1*e1' + A*e2*e2' + A*e3*e3'
Lorsque une base (e1,e2,e3) de l'espace E est fixé, il est créé canoniquement une base de l'espace E' dite base dual (e1',e2',e3'), et il est créé canoniquement une base dans l'espace des endomorphismes de E qui est (e1*e1', e1*e2', e1*e3', e2*e1', e2*e2', e2*e3', e3*e1', e3*e2', e3*e3') et dont les endomorphismes qui la compose possèdent les représentations matriciels suivantes :
[1,0,0] [0,1,0] [0,0,1]
e1*e1' = [0,0,0] e1*e2' [0,0,0] e1*e3' = [0,0,0]
[0,0,0] [0,0,0] [0,0,0]
[0,0,0] [0,0,0] [0,0,0]
e1*e1' = [1,0,0] e1*e2' [0,1,0] e1*e3' = [0,0,1]
[0,0,0] [0,0,0] [0,0,0]
[0,0,0] [0,0,0] [0,0,0]
e1*e1' = [0,0,0] e1*e2' [0,0,0] e1*e3' = [0,0,0]
[1,0,0] [0,1,0] [0,0,1]Nous avons e1*e1' + e2*e2' + e3*e3' = Id, l'automorphisme identité, définie par Id(v) = v pour tout v.
On définie les matrices de matrices de mêmes tailles et d'éléments de K comme dans l'exemple reprenant les deux facons de décomposer End(E) en sommes directes.
A = [A(e1), A(e2), A(e3)]
[A1]
A = [A2]
[A3]où A1, A2, A3 sont des éléments de E', donc des matrices lignes d'élément de K, et où A(e1), A(e2), A(e3) sont des vecteurs de E donc des matrices colonnes d'élément de K. L'endomorphisme A possède une représentation en matrice colonne dans la somme directe End(E) = e1*E' + e2*E' + e3*E' et possède une représentation en matrice ligne dans la somme directe End(E) = E*e1' + E*e2' + E*e3' et possède une représentation en matrice carrée dans la somme directe End(E) = K*e1*e1' + K*e1*e2' + K*e1*e3' + K*e2*e1' + K*e2*e2' + K*e2*e3' + K*e3*e1' + K*e3*e2' + K*e3*e3'. Y a-t-il un moyen d'unifier ces différents types de matrices ?. Oui car le produit matriciel respecte la subdivision en blocs : Le produit par blocs de deux matrices fournit, quand il est possible, une subdivision en blocs du produit de ces matrices. Ainsi A peut se comporter soit comme une matrice ligne ou comme une matrice colonne selon le cas, et nous pouvons écrire le produit de A par une matrice colonne ou une matrice ligne,c'est à dire par un vecteur ou une forme ou un autre endomorphisme représenté par une matrice colonne ou une matrice ligne :
[v1]
A*v = [A(e1),A(e2),A(e3)] * [v2] = A(e1)*v1 + A(e2)*v2 + A(e3)*v3 = A(v)
[v3][A1] [A1*f1, A1*f2, A1*f3]
A*f = [A2] * [f1, f2, f3] = [A2*f1, A2*f2, A2*f3]
[A3] [A3*f1, A3*f2, A3*f3][B1]
A*B = [A(e1),A(e2),A(e3)] * [B2] = A(e1)*B1 + A(e2)*B2 + A(e3)*B3
[B3][A1] [A1*B(e1), A1*B(e2), A1*B(e3)]
A*B = [A2] * [B(e1),B(e2),B(e3)] = [A2*B(e1), A2*B(e2), A2*B(e3)]
[A3] [A3*B(e1), A3*B(e2), A3*B(e3)]
On peut vérifier que les deux façons de calculer A*B donnent un résultat identique en développant complètement le produit matriciel avec les expressions suivantes :
A1 = [A11, A12, A13] B1 = [B11, B12, B13]
A2 = [A21, A22, A23] B2 = [B21, B22, B23]
A3 = [A31, A32, A33] B3 = [B31, B32, B33]
[A11] [A12] [A13]
A(e1) = [A21] A(e2) = [A22] A(e3) = [A23]
[A31] [A32] [A33]
[B11] [B12] [B13]
B(e1) = [B21] B(e2) = [B22] B(e3) = [B23]
[B31] [B32] [B33]Nous avons également la représentation des endomorphismes sous forme de matrice carrée. La définition du produit matriciel est étendue en autorisant la subdivision des matrices en blocs et en autorisant la multiplication d'une matrice quelconque par un scalaire de K.
[A11,A12,A13] [v1] [A11*v1 + A12*v2 + A13*v3]
A*v = [A21,A22,A23] * [v2] = [A21*v1 + A22*v2 + A23*v3]
[A31,A32,A33] [v3] [A31*v1 + A32*v2 + A33*v3][A11, A12, A13] [B11, B12, B13]
A*B = [A21, A22, A23] * [B21, B22, B23]
[A31, A32, A33] [B31, B32, B33][A1] [A1*v]
A*v = [A2] * v = [A2*v] = e1*A1*v + e2*A2*v + e3*A3*v = A(v)
[A3] [A3*v]A*f = A*[f1, f2, f3] = [A*f1, A*f2, A*f3]
[u1] [u1*v]
u*v = [u2]*v = [u2*v]
[u3] [u3*v]u*v est un élément de l'espace vectoriel E^3. Le produit matriciel ainsi défini permet de construire différents K-espace vectoriel.
...Leçon d'algèbre moderne, A. LENTIN & J. RIVAUD, Vuibert, 1964
L'encyclopédie libre Wikipédia http://fr.wikipedia.org
----
.
Les expressions de ces éléments peuvent se réduire selon quelques règles. Les expressions de la forme q1 + q2 ou -q1, où q1 et q2 sont des entiers relatifs quelconques, se transforment en une expression q3, ou q3 est un entier relatif. Et il ne reste que l'opération de produit * appliqué à des éléments non nuls, qui ne peut pas se réduire. Les éléments engendrés admettent donc une forme réduite :
q1*q2*q3 ... *qn
où q1, q2, q3 ..., qn sont n entiers relatifs, et où n est un entier strictement positif. Les signes et le zero peuvent se résoudrent en un seul signe ou zero noté ε. Les éléments engendrés admettent la forme réduite suivante :
ε*q1*q2*q3 ... *qn
où ε∈{1,0,-1} et où q1, q2, q3 ..., qn sont n entiers strictement positifs, et où n est un entier positif ou nul.
La commutatitvité permet de réduire encore davantage la forme réduite des éléments engendrés par les opérateurs de base de l'anneau. Ils ont maintenant la forme suivante :
ε*p1a1*p2a2*p3a3 ... pnan
où ε∈{1,0,-1} et où p1, p2, p3 ..., pn sont n entiers premiers distincts mis en ordre croissant, et où a1, a2, a3 ..., an sont n entiers strictement positifs, et où n est un entier positif ou nul. Les entiers premiers sont {2, 3, 5, 7, 11, 13, 17, 19, 23 ...}. On note A2 l'ensemble de ces expressions et A2+ l'ensemble de ces expressions où ε = 1. On définie un langage de niveau 2 utilisant ces expressions :
Le symbôle @S qui apparait dans la présentation désigne l'énumération des éléments de S qui sont ici proposé comme élément générateur. le symbôme * représente la loi de produit du semi-groupe qui peut être préalablement définie. Par défaut sa définition est * : (x,y)-->x*y, et la structure < @S, * > représente une structure libre sur un ensemble énumérable de génrateurs.
1.3) Le langage du premier ordre
On définie le prédicat comme étant un opérateur retournant la valeur logique 0 ou 1.
On définie un prédicat particulier qu'est l'égalité, notée =.
On autorise toutes les opérations logiques.
On autorise des variables muettes quantifiée existanciellement ou universellement.
Et on autorise l'extension du langage par des éléments ou opérateurs d'arité n.Le quantificateur existentiel n'est pas utilisé. Il est remplacé par une extension du langage, et un opérateur ainsi ajouté, précise dans la formule exactement de quoi il dépend. Par exemple : On choisie un langage L comprenant le prédicat P d'arité 6, et augmenté de 3 variables muettes L. Puis on considère l'extension L[a(.,.), b(.), c(.)]. La formule suivante :
∃a(.,.)∃b(.)∃c(.), ∀x∀y∀z, P(x, y, z, a(x,y), b(x), c(x,y,z))
admet une négation dans le langage L[x(.,.), y(.), z(.)] qui est :
∀x∀y∀z, ¬P(x(a,b,c), y(a,c), z(c), a, b, c)
1.3) Le langage du second ordre
On définie le prédicat comme étant un opérateur retournant la valeur logique 0 ou 1.
On définie un prédicat particulier qu'est l'égalité, notée =.
On autorise toutes les opérations logiques.
On autorise des variables muettes quantifiée universellement.
Et on autorise l'extension du langage par des éléments ou opérateurs d'arité n.Le quantificateur existentiel n'est pas utilisé. Il est remplacé par une extension du langage, et un opérateur ainsi ajouté, précise dans la formule exactement de quoi il dépend. Par exemple : On choisie un langage L comprenant le prédicat P d'arité 6, et augmenté de 3 variables muettes L. Puis on considère l'extension L[a(.,.), b(.), c(.)]. La formule suivante :
∃a(.,.)∃b(.)∃c(.), ∀x∀y∀z, P(x, y, z, a(x,y), b(x), c(x,y,z))
admet une négation dans le langage L[x(.,.), y(.), z(.)] qui est :
∀x∀y∀z, ¬P(x(a,b,c), y(a,c), z(c), a, b, c)
Niveau 0 :
a, b, c. n0 N0 = n0 Niveau 1 :
fa-fc, ga-gc, ha-hc, n1*n0 Uaa-Uac, Uba-Ubc, Uca-Ucc, Vaa-Vcc, Waa-Wcc. n2*n02 N1 = n1*n0 Niveau 2 :
Eléments ffa-fWcc, gfa-gWcc, hfa-hWcc, n2*N1 a*b2 + a2*b*c
Uafa-UaWcc, Ubfa-UbWcc, Ucfa-UcWcc, a*N1 a2*b + a3*c Ufaa-Ufcc, Ugaa-Ugcc, Uhaa-Uhcc a2*b a2*b*c + a3*c2 UUaaa-UUccc, UVaaa-UVccc, UWaaa-UWccc, a3*c Vfaa-VWccc, Wfaa-WWccc. (c-1)*(a2*b +a3*c ) N2 = a*b2 + 2*a2*b*c + a2*b + a3*c + a3*c2
Niveau 3 :
fffa-fWWccc, gffa-gWWccc, hffa-hWWccc,
Uaffa-UaWWccc, Ubffa-UbWWccc, Ucffa-UcWWccc, Ufafa-UfWccc, Ugafa-UgWccc, Uhafa-UhWccc,
UUafa-UUWccc, UVafa-UVWccc, UWafa-UWWccc,
Vaffa-VWWccc, Waffa-WWWccc.niveau 4 :
ffffa-fWWWccc, gfffa-gWWWccc, hfffa-hWWWccc,
uafa
uafb
uaga
uagb
uauaa
...
uavbb
ubfa
ubfb
...
ubvbb
ufaa
...
uavbb
ubfa
...
ubvbb
ufaa
ufab
ufba
ufbb
ugaa
ugab
ugba
ugbb
uuaaa
uuaab
uuaba
...
uubbb
uvaaa
....
uavbb
u
1.2) Le raisonnement mathématique
Le raisonnement mathématique est exacte comme le rouage d'une machine idéale dans laquel il n'y aurait aucun jeu, aucun grain de sable et aucun aléatoire. On peut donc le comparer à l'exécution d'un programme informatique de taille finie ou chaque instruction opère un changement exacte sur une mémoire exacte, au sens de la mécanique classique. Démontrer signifie construire, construire une démonstration, c'est à dire programmer .
Le raisonnement est mécanique. Il utilise un certain nombre de règles appelées axiomes, et les applique sur une construction finie, une sorte de jeu de légos, dont la base est le langage d'opérateurs. Chaque formule est soit démontrable, ou indémontrable. C'est à dire que chaque formule et soit constructible à l'aide des règles du raisonnement ou soit inconstructible à l'aide des règles du raisonnement. Les formules démontrable sont dites vrai.
Puis on définie un second système de raisonnement symétrique du premier qui construit les formules dite fausses selon un même principe. Ces deux systèmes sont dits cohérents si aucune formule exprimable dans le langage des deux systèmes ne peut être démontrée dans les deux systèmes à la fois. Et ces deux systèmes sont dits complet si toute formule exprimable dans le langage des deux systèmes est démontrable par l'un ou par l'autre système.
Une formule mathématique est un objet de taille finie constructible dans le langage d'opérateurs qui constitue sa partie déclarative. Son corps est un terme de ce langage.