Matrice vide

En mathématiques, une matrice vide est définie comme une matrice dont l'une des dimensions m ou n est nulle ; il s'agit donc de matrices de dimension m × 0, 0 × n ou bien 0 × 0.

Une matrice pouvant être définie abstraitement par une famille finie d'éléments d'un ensemble K (souvent un anneau commutatif ou un corps) indexée par un produit cartésien I × J où I et J sont des ensembles finis, une matrice vide correspond au cas où soit I soit J est l'ensemble vide.

Ces matrices sont utiles pour travailler avec l'espace nul K⁰ (K étant un corps commutatif quelconque, habituellement ℝ ou ℂ). Elles permettent donc d'appliquer les matrices à cet espace vectoriel trivial. D'un point de vue pratique, les matrices vides étendent la validité de théorèmes à des cas limites ; elles permettent par exemple d'utiliser des équations de dynamique à des situations statiques. En informatique, une matrice vide peut être le résultat d'une recherche infructueuse ou bien survenir au début ou à la fin d'un algorithme itératif ; l'extension des règles de l'algèbre aux cas limite des matrices vides permet donc d'éviter de traiter ces cas comme des exceptions.

Une matrice vide en tant que représentant d'une application linéaire

L'espace nul K⁰ ne contient qu'un seul élément, le « vecteur vide » (le vecteur n'ayant aucune coordonnée). Un espace vectoriel ayant nécessairement un élément neutre, ce vecteur vide est le vecteur nul de K⁰ noté 0_K⁰ :

$K^{0}=\{0_{K^{0}}\}$

L'espace nul est de dimension 0. Considérons maintenant un K-espace vectoriel E quelconque. Il n'existe qu'une seule application linéaire de E dans K⁰, celle transformant tout vecteur de E en ce vecteur nul (c'est l'application nulle). L'ensemble des applications linéaires de E dans K⁰ est donc un singleton.

$L(E,K^{0})=\left\{f_{E,K^{0}}\right\}$ avec

${\begin{matrix}f_{E,K^{0}}:&E&\rightarrow &K^{0}\\&x&\mapsto &0_{K^{0}}\end{matrix}}$

Si l'on appelle n la dimension de E, alors il existe une unique matrice de dimension n × 0 qui représente cette application linéaire unique, c'est une matrice vide que l'on pourra noter ()_{n, 0}.

De même, il n'existe qu'une seule application linéaire de K⁰ dans E, l'image de K⁰ par cette application étant le vecteur nul de E puisque l'unique élément de K⁰ est le vecteur nul (c'est donc également l'application nulle). L'ensemble des applications linéaires de K⁰ dans E est également un singleton.

$L(K^{0},E)=\left\{f_{K^{0},E}\right\}$ avec

${\begin{matrix}f_{K^{0},E}:&K^{0}&\rightarrow &E\\&x&\mapsto &0_{E}\end{matrix}}$

Il existe donc une unique matrice de dimension 0 × n représentant cette applications linéaire, la matrice vide ()_{0, n}.

En tant que représentant d'une application nulle, une matrice vide est une matrice nulle :

$()_{n,0}=0_{n,0};()_{0,n}=0_{0,n}$.

La matrice vide de dimension 0×0, que l'on peut noter ()_{0, 0}, représente en particulier l'identité Id₀ de l'espace nul. C'est donc une matrice inversible (régulière), donc carrée. Puisqu'elle représente également l'application nulle, nous avons donc :

$()_{0,0}=\mathrm {Id} _{0}=0_{0,0},$

c'est-à-dire que dans l'anneau nul des matrices de dimension 0×0, l'unique élément est neutre à la fois pour le produit et pour la somme.

Propriétés des matrices vides

Dans ce qui suit, la notation « () » désigne une matrice vide de dimension quelconque ()_{n, 0}, ()_{0, n} ou ()_{0, 0}.

• l'image de toute matrice vide est réduite au vecteur nul : Im () = {0} ; le rang de toute matrice vide est donc nul : rg() = 0 ;
• le noyau d'une matrice vide dépend de ses dimensions :
  • Ker ()_{0, n} = {0},
  • Ker ()_{n, 0} = Kⁿ ;
• la norme de toute matrice vide est nulle : ║()║ = 0 ;
• la transposée d'une matrice vide est encore vide ;
• le produit dépend de la dimension de la matrice vide considérée : pour une matrice A de dimension (m × n) et une matrice B de dimension (n × p), au moins un des entiers m, n et p étant nul ; AB est une matrice de dimension (m × p) et donc :
  • si m = 0 , alors AB est une matrice de dimension (0 × p) donc une matrice vide : ()_{0, n} × B = ()_{0, p},
  • si p = 0, alors AB est une matrice de dimensions (m × 0), c'est également une matrice vide : A × ()_{n, 0} = ()_{m, 0},
  • mais si n = 0 et si m ≠ 0 et p ≠ 0, alors la matrice AB est la matrice nulle de dimension (m × p)

    ()_{m, 0} × ()_{0, p} = 0_{m, p} ; concrètement, la multiplication des matrices correspond à la composition d'applications linéaires, nous avons ici la composition de deux applications nulles, la résultante est logiquement l'application nulle de l'espace de départ K^p vers l'espace d'arrivée K^m ;

Concernant la somme : l'addition de matrices est une loi de composition interne, les matrices ont donc nécessairement la même dimension. Ainsi, on ne peut écrire « A + () » ou bien « () + A » que si A est elle-même une matrice vide identique, le résultat est donc également une matrice vide.

Pour la matrice vide de dimension 0 × 0 :

• ()_{0, 0} = I₀ (matrice identité) donc :
  • la matrice est sa propre inverse : ()_{0, 0}^–1 = ()_{0, 0},
  • la matrice ()_{0, 0} à valeurs réelles est orthogonale ;
• conditionnement :
  • certains retiennent la convention cond()_{0, 0} = 0 par calcul (puisque la norme est nulle),
  • d'autres retiennent cond()_{0, 0} = 1 par application de la notion de conditionnement (une précision parfaite correspondant à un score de 1 et la matrice vide est une identité, les matrices unités ayant toutes un conditionnement de 1) ;
• déterminant : det ()_{0, 0} = 1 ; c'est une conséquence de la notion de produit vide dans la formule de Leibniz et c'est cohérent avec le fait que c'est une matrice identité ;
• son polynôme caractéristique est 1 d'après le point précédent ;
• ce polynôme n'a pas de racine donc la matrice n'a pas de valeur propre (et donc pas de vecteur propre) ;
• la matrice vide est nulle donc à la fois symétrique et antisymétrique, et de trace nulle.

Dans les langages de programmation

Matlab

Jusqu'à sa version 4, Matlab n'acceptait qu'une matrice vide notée []. À partir de sa version 5, il distingue les matrices vides 0 × 0 (notée []), 0 × 1 et 1 × 0. On peut obtenir une matrice vide 0 × 1 par

>> zeros(0, 1)

ans =

   Empty matrix: 0-by-1
>> a = ones(3, 2)
a =

     1     1
     1     1
     1     1
>> b = zeros(3, 2)
b =

     0     0
     0     0
     0     0
>> c = find(a<b)
c =

   Empty matrix: 0-by-1

Le logiciel vérifie la compatibilité des dimensions des matrices vides pour le produit et la somme. Si l'on ajoute un scalaire à la matrice vide — ce qui revient dans Matlab à ajouter le scalaire à tous les éléments de la matrice vide —, Matlab retourne la matrice vide.

>> 5 + c
c =

   Empty matrix: 0-by-1

Concernant le produit, on a :

>> c*c'

ans =

     []

>> c'*c

ans =

     0

On a également sum(c) == 0 et prod(c) == 1 car ce sont les éléments neutres de la somme et du produit respectivement.

Seule la matrice vide 0 × 0 est considérée comme carrée et inversible. On a alors det([]) == 1, inv([]) == [] et cond([]) == 0.

GNU Octave dispose également de ces trois matrices vide avec un comportement similaire.

Scilab

Le logiciel Scilab ne définit qu'une seule matrice vide notée []. L'exemple précédent donne dans Scilab :

--> zeros(0, 1)
 ans  =

    []
--> a = ones(3, 2)
 a  = 

   1.   1.
   1.   1.
   1.   1.
--> b = zeros(3, 2)
 b  = 

   0.   0.
   0.   0.
   0.   0.
--> c = find(a<b)
 c  = 

    []

Le logiciel autorise le produit et la somme avec une matrice vide sans vérifier les dimensions. On a :

• [] + A == A + [] == A jusqu'à sa version 5.5.2 et
• [] + A == A + [] == [] à partir de sa version 6.0.0 ;
• A*[] == []*A == [] ;
• sum([]) == 0 et prod([]) == 1 ;
• det([]) == 0 ;
• inv([]) == [] ;
• cond([]) == 1.

R

Le logiciel R permet de créer des matrices vides de toutes dimensions. Par exemple :

> M <- matrix(, nrow = 3, ncol = 0) # matrice vide 3 × 0
> print(M)
    
[1,]
[2,]
[3,]

> sum(M)
[1] 0

> prod(M)
[1] 1

> N <- aperm(M, c(2, 1)) # transposée, matrice vide 0 × 3
> print(N)
     [,1] [,2] [,3]

> N %*% M # produit matriciel
<0 x 0 matrix>

> M %*% N
     [,1] [,2] [,3]
[1,]    0    0    0
[2,]    0    0    0
[3,]    0    0    0

> O <- matrix(, nrow = 0, ncol = 0) # matrice vide 0 × 0
> print(O)
<0 x 0 matrix>

> det(O) # déterminant
[1] 1
> A <- matrix(1:6, nrow=2) # matrice 2 × 3
> print(A)
     [,1] [,2] [,3]
[1,]    1    3    5
[2,]    2    4    6

> A %*% M
    
[1,]
[2,]

Maxima

Le logiciel Maxima ne permet de créer que des matrices colonne vides ()_{n, 0} et la matrice carrée vide ()_{0, 0} :

(%i1) A:matrix()
(%o1) matrix()

(%i2) length(A)
(%o2) 0

(%i3) B:matrix([], [], [])
      ┌ ┐
      │ │
(%o3) │ │
      │ │
      └ ┘

(%i2) length(B)
(%o2) 3

(%i5) transpose(B)
(%o5) matrix()

(%i6) C:matrix([])
(%o6) matrix([])

(%i7) length(C)
(%o7) 1

Notez que matrix() est la matrice ()_{0, 0} ; Maxima n'est pas cohérent puisque charpoly(A, x), qui calcule le polynôme caractéristique d'une matrice, renvoie une erreur indiquant que A n'est pas carrée mais a pour dimension 1 × 0. L'expression matrix([]) donne la matrice 1 × 1 qui contient le vecteur vide et qui, pour Maxima, est différente de matrix(). La transposée d'une matrice ()_{n, 0} donne la matrice ()_{0, 0.}

Python

La librairie numpy permet de créer une matrice vide (ci dessous, la matrice se compose de 0 lignes et 5 colonnes)

import numpy as np  
x = np.empty((0, 5))

Bibliographie

• [de Boor 1990] (en) Carl de Boor, « An empty exercise », ACM SIGNUM Newsletter, vol. 25, n^o 4,‎ octobre 1990, p. 2-6 (DOI 10.1145/122272.122273, lire en ligne)
• [Nett et Haddad 1993] (en) C. N. Nett et W. M. Haddad, « A system-theoretic appropriate realization of the empty matrix concept », IEEE Transactions on Automatic Control, vol. 38, n^o 5,‎ 1993, p. 771-775 (DOI 10.1109/9.277245, lire en ligne)