Lois, structures, matrices en informatique INFO2 - Semaines 43 & 45 Guillaume CONNAN

(1)

Lois, structures, matrices en informatique

INFO2 - Semaines 43 & 45

Guillaume CONNAN

IUT de Nantes - Dpt d’informatique

Dernière mise à jour : 24 octobre 2013 à 14:48

(IUT de Nantes - Dpt d’informatique ) 1 / 109

(2)

Sommaire

1 Loi de composition 2 Groupes

3 Anneaux et corps

4 Aparté : ze Haskell Touch 5 Structure d’espace vectoriel 6 Les matrices

(3)

Loi de composition

Sommaire

3 Anneaux et corps

(4)

Loi de composition Définitions

Définition 1 (Loi de composition interne (LCI))

Une loi de composition interne définie sur un ensemble E est une fonction totale (ou application) deE_⊗E dans E. On dit alors que E est un magma.

(5)

Définition 2 (Stabilité)

Un ensemble E est stable par une opération_? si, et seulement si :

³

∀〈x,y〉´³

¡〈x,y〉 ∈E⊗E^¢→¡

x_?y∈E^¢^´

(6)

Définition 3 (Loi de composition externe (LCE))

Une loi de composition externe définie sur un ensemble E et à opérateurs dans un ensemble K est une fonction totale (ou application) de K_⊗E dans E.

(7)

Définition 4 (Morphisme)

Soit_〈E,?〉 et_〈F, †〉deux magmas et_ϕ une fonction totale deE dansF. On dit que _ϕest un morphisme de E dans F si, et seulement si :

¡∀x^¢¡∀y^¢¡_ϕ(x_?y)=ϕ(x)†ϕ(y)^¢

(8)

Définition 5 (Isomorphisme)

Soit_〈E,?〉 et_〈F, †〉deux magmas et_ϕ une fonction totale deE dansF. On dit que _ϕest un morphisme de E dans F si, et seulement si, c’est un morphisme BIJECTIF de E dans F.

(9)

Loi de composition Propriétés des lois (de composition interne)

Définition 6 (Commutativité)

Une LCI_?sur E est commutative si, et seulement si (_∀x)(_∀y)(x_?y₌y_?x)

(10)

Définition 7 (Associativité)

Une LCI_?sur E est associative si, et seulement si (_∀x)(_∀y)(_∀z)(x_?(y_?z)₌(x_?y)_?z)

Un magma muni d’une loi associative est appelé... un magma associatif.

(11)

Définition 8 (Élément neutre)

Un élément neutre e d’une LCI_?sur E est un élément e_? qui vérifie : (∀x)(x_?e_?=e_?_?x=x)

Un magma associatif admettant un élément neutre est unmonoïde (ou un magma associatif unifère).

Pouvez-vous démontrer que si l’élément neutre existe, il est unique ?

(12)

(13)

(14)

Définition 9 (Élément symétrisable)

Soitx un élément de E. Il est inversible (ou symétrisable) par_? si, et seulement si,

(_∃y)(x_?y₌y_?x₌e_?)

Pouvez-vous démontrer que six admet un symétrique, alors ce symétrique est unique ?

(15)

(_∃y)(x_?y₌y_?x₌e_?)

(16)

(_∃y)(x_?y₌y_?x₌e_?)

(17)

Définition 10 (Régularité)

Un élément ade E est dit régulier à gauche (ousimplifiable à gauche) si, et seulement si :

¡∀x^¢¡_∀y^¢¡(a_?x₌a_?y)_→(x₌y)^¢ On a une définition similaire de la régularité à droite.

Un élément à la fois régulier à gauche et à droite est dit régulier.

Une loi telle que tout élément soit régulier est dite régulière.

Un élément inversible est régulier (vérifiez-le). Un élément régulier est-il inversible ?

(18)

(19)

(20)

Définition 11 (Distributivité)

On dit que la loi _?définie sur E est distributive sur†définie sur E si, et seulement si :

³

∀x^´³∀y^´³∀z^´³^¡x_?(y†z)=(x_?y)†(x_?z)^¢∧¡

(y†z)_?x=(y_?x)†(z_?x)^¢^´

(21)

Définition 12 (Élément absorbant)

Un élément absorbant d’une LCI _?sur E est un élémenta_? qui vérifie : (_∀x)(x_?a_?₌a_?_?x₌a_?)

Montrez que si un tel élément existe, il est unique.

(22)

(23)

(24)

Définition 13 (Élément involutif)

Soit_?une loi sur un ensemble E admettant un élément neutre e_?. Alorsx est involutif si, et seulement si,x_?x=e_?.

Définition 14 (Élément idempotent) Soit_?une loi sur un ensemble E.

Alorsx est idempotentsi, et seulement si,x_?x₌x.

(25)

(26)

(27)

Groupes

Sommaire

3 Anneaux et corps

(28)

Groupes

(29)

Groupes

Définition 15 (Groupe)

Un groupe est un monoïde tel que tout élément est inversible.

Définition 16 (Sous-groupe)

〈H_,?〉est un sous-groupe de _〈G,?〉 si, et seulement si, H est une partie de G et _〈H,?〉est un groupe.

(30)

Groupes

(31)

Groupes

(32)

Anneaux et corps

Sommaire

3 Anneaux et corps

(33)

Anneaux et corps Anneaux

(34)

Définition 17 (Anneau)

Soit A un ensemble muni de deux lois et.

On dit que _〈A,^, 〉est un anneau si, et seulement si :

〈A,〉est un groupe commutatif ; est associative ;

est distributive sur.

Si est commutative, alors l’anneau est dit commutatif.

Si admet un élément neutre, l’anneau est ditunitaire.

Les éléments d’un anneau unitaire qui admettent un symétrique par sont dits inversibles. On note A^∗ l’ensemble des éléments inversibles de A.

(35)

(36)

(37)

(38)

(39)

(40)

(41)

(42)

Anneaux et corps Corps

Définition 18 (Corps)

Soit_K un ensemble muni de deux LCIet . Le triplet_〈K,^, 〉 possède une structure decorpssi, et seulement si,

〈K,^, 〉a une structure d’anneau unitaire ;

〈K\ {e}, 〉a une structure de groupe.

Combien d’éléments a au minimum un corps ?

(43)

(44)

(45)

(46)

(47)

Anneaux et corps La classes numériques sur Haskell

class ⁽Eq â, Show â) => Num â where (+), (-), (*) :: a -> a -> a negate :: a -> a abs, signum :: a -> a fromInteger ^:: Integer ^{-> a}

À quelle structure algébrique peut-on associer la classeNum?

(48)

class ⁽Eq â, Show â) => Num â where (+), (-), (*) :: a -> a -> a negate :: a -> a abs, signum :: a -> a fromInteger ^:: Integer ^{-> a}

À quelle structure algébrique peut-on associer la classeNum?

(49)

class ⁽Num ^a) =>Fractional ^a where (/) :: a -> a -> a recip :: a -> a

fromRational ^:: Rational ^{-> a}

À quelle structure algébrique peut-on associer la classeFrational?

(50)

class ⁽Num ^a) =>Fractional ^a where (/) :: a -> a -> a recip :: a -> a

fromRational ^:: Rational ^{-> a}

À quelle structure algébrique peut-on associer la classeFrational?

(51)

Aparté : ze Haskell Touch

Sommaire

3 Anneaux et corps

(52)

John Backus (1924 - 2007)

Much of my work has come from being lazy

(53)

John Backus (1924 - 2007)

Much of my work has come from being lazy

(54)

Aparté : ze Haskell Touch Les fonctions

Spécifier

SPÉCIFIER la fonction : c’est-à-dire parfois (on peut effectivement s’en passer au besoin) la nommer, donner sontype, i.e. son domaine et son codomaine : on parle designature de type et on explique ce qu’elle fait.

double :: Int -> Int

−− c a l c u l e l e d o u b l e d ’ un e n t i e r : l e r é s u l t a t e s t un e n t i e r

(55)

Spécifier

SPÉCIFIER la fonction : c’est-à-dire parfois (on peut effectivement s’en passer au besoin) la nommer, donner sontype, i.e. son domaine et son codomaine : on parle designature de type et on explique ce qu’elle fait.

double :: Int -> Int

−− c a l c u l e l e d o u b l e d ’ un e n t i e r : l e r é s u l t a t e s t un e n t i e r

(56)

Réaliser

RÉALISER la fonction c’est associer à la fonction spécifiée une expression.

Pour cela, on utilise desparamètres formels qui font abstraction des valeurs particulières qui leur seront ensuitesubstituées.

double n = 2 * n

(57)

Réaliser

RÉALISER la fonction c’est associer à la fonction spécifiée une expression.

Pour cela, on utilise desparamètres formels qui font abstraction des valeurs particulières qui leur seront ensuitesubstituées.

double n = 2 * n

(58)

Utiliser

UTILISER a fonction dans une expression en lui donnant desparamètres effectifs (arguments), c’est-à-dire liés à l’application particulière de la fonction :

*Main> (double 3) + (double 7) 20

(59)

Utiliser

UTILISER a fonction dans une expression en lui donnant desparamètres effectifs (arguments), c’est-à-dire liés à l’application particulière de la fonction :

*Main> (double 3) + (double 7) 20

(60)

Aparté : ze Haskell Touch Curryfication

Haskell Curry (1900 - 1982)

(61)

(62)

Unefonction curryfiéeest une fonction de plusieurs variables transformée en une fonction d’une seule variable qui renvoie une fonction ayant une variable de moins...

Cela permet de créer des fonctions partielles.

(63)

Unefonction curryfiéeest une fonction de plusieurs variables transformée en une fonction d’une seule variable qui renvoie une fonction ayant une variable de moins...

Cela permet de créer des fonctions partielles.

(64)

plus x y = x + y

plus :: Integer ^-> Integer ^-> Integer

plus x y = x + y

Associativité

f = plus 3

Que vaut f(5)?

*Main^{> f 5} 8

*Main^{> :t f}

f :: Integer -> Integer

(65)

plus x y = x + y

Associativité

f = plus 3

Que vaut f(5)?

*Main^{> f 5} 8

*Main^{> :t f}

(66)

plus x y = x + y

Associativité

f = plus 3

Que vaut f(5)?

*Main^{> f 5} 8

*Main^{> :t f}

(67)

plus x y = x + y

Associativité

f = plus 3

Que vaut f(5)?

*Main^{> f 5} 8

*Main^{> :t f}

(68)

plus x y = x + y

Associativité

f = plus 3

Que vaut f(5)?

*Main^{> f 5} 8

*Main^{> :t f}

(69)

plus x y = x + y

Associativité

f = plus 3

Que vaut f(5)?

*Main^{> f 5} 8

*Main^{> :t f}

(70)

plus x y = x + y

Associativité

f = plus 3

Que vaut f(5)?

*Main^{> f 5} 8

*Main^{> :t f}

(71)

F(D,A)

plus∈F^¡_N,F(_N,_N)^¢

(72)

F(D,A)

plus∈F^¡_N,F(_N,_N)^¢

(73)

Aparté : ze Haskell Touch Un exemple

Exemple 19

Décrire une fonction qui étant donnés quatre flottants leur associe la moyenne des deux nombres parmi les quatre qui ne sont ni le plus grand ni le plus petit. Par exemple, la moyenne olympique de 10, 8, 12 et 14 est 11 et celle de 12, 12, 12 et 12 est 12.

(74)

Spécification

moyenne_olympique4 :: Float -> Float -> Float -> Float -> Float

−− r e n v o i e l a moyenne o l y m p i q u e de 4 f l o t t a n t s s o u s forme d ’ un f l o t t a n t

(75)

Réalisation

Nous allons par exemple additionner les quatre nombres, retirer le plus grand et le plus petit puis diviser par 2.

*Main^{> :t} min

min ^:: Ord ^a => a -> a -> a

*Main> min ’a’ ’b’

’a’

*Main> min 5 3 3

*Main^> min "Tralala" "Pouet Pouet"

"Pouet Pouet"

*Main^> min True False False

(76)

Réalisation

*Main^{> :t} min

min ^:: Ord ^a => a -> a -> a

’a’

*Main> min 5 3 3

"Pouet Pouet"

(77)

Réalisation

*Main^{> :t} min

min ^:: Ord ^a => a -> a -> a

’a’

*Main> min 5 3 3

"Pouet Pouet"

(78)

Réalisation

moyenne_olympique4 a b c d =

(s - mini - maxi) / 2 ₋₋ l ’ e x p r e s s i o n c o r r e s p o n d a n t à l a mé t h o d e c h o i s i e

where s = a + b + c + d ₋₋ l a somme d e s 4 nombres

mini = min ^{a (}min ^{b (}min ^{c d) )} −− l e p l u s p e t i t d e s 4 maxi = max ^{a (}max ^{b (}max ^{c d) )} −− l e p l u s grand d e s 4

*Main> moyenne_olympique4 10 8 12 14 11.0

(79)

Réalisation

moyenne_olympique4 a b c d =

(s - mini - maxi) / 2 ₋₋ l ’ e x p r e s s i o n c o r r e s p o n d a n t à l a mé t h o d e c h o i s i e

where s = a + b + c + d ₋₋ l a somme d e s 4 nombres

mini = min ^{a (}min ^{b (}min ^{c d) )} −− l e p l u s p e t i t d e s 4 maxi = max ^{a (}max ^{b (}max ^{c d) )} −− l e p l u s grand d e s 4

*Main> moyenne_olympique4 10 8 12 14 11.0

(80)

Aparté : ze Haskell Touch Polymorphisme - abstraction - récursion - listes

Exemple 20

Décrire une fonction qui étant donnée une liste d’au moins quatre nombres leur associe la moyenne des nombres parmi ceux de la liste qui ne sont ni le plus grand ni le plus petit. Par exemple, la moyenne olympique de 15, 7, 10, 8, 12 et 14 est 11.

(81)

Min et Max polymorphes

minListe :: (Ord ^a) => [a] -> a

−− r e n v o i e l e m i n i d ’ une l i s t e d ’ é l é ments o r d o n n a b l e s

maxListe :: (Ord ^a) => [a] -> a

−− r e n v o i e l e maxi d ’ une l i s t e d ’ é l é ments o r d o n n a b l e s

extr_liste :: (Ord a) => (a -> a -> a) -> [a] -> a

−− r e n v o i e l e m i n i ou l e maxi ( on c h o i s i t en m e t t a n t l a n a t u r e de l ’ extremum en param è t r e ) d ’ une l i s t e d ’ é l é ments o r d o n n a b l e s

(82)

Min et Max polymorphes

(83)

Min et Max polymorphes

(84)

(85)

m_o4 :: (Fractional ^t, Ord ^t) => t -> t -> t -> t -> t

m_o4 a b c d =

(s - mini - maxi) / 2 where ^{

s = a + b + c + d ;

mini = min ^{d (}min ^{c (}min ^{a b)) ;} maxi = max d (max c (max a b))

}

(86)

som_liste :: (Num typ) => [typ] -> typ

som_liste [] =

error "Ta liste est vide !!"

som_liste (tete_de_liste : []) =

tete_de_liste

som_liste (tete_de_liste : liste_décapitée) = (+) tete_de_liste (som_liste liste_décapitée)

(87)

minListe :: ( Ord t)=> [t] -> t

minListe [] =

minListe (tete : []) =

tete

minListe (tete : liste_décapitée) =

min tete (minListe liste_décapitée)

(88)

maxListe [] =

maxListe (tete : []) =

tete

maxListe (tete : liste_décapitée) = max tete (maxListe liste_décapitée)

(89)

(90)

op_liste = foldl1 fold comme...

lcomme...

(91)

lcomme...

(92)

lcomme...

(93)

: :

: Vide 7

2.5 3

2 4

min 4 min

2 min

3 min

2.5 7

(94)

*Main> :t opListe

opListe :: (a -> a -> a) -> [a] -> a

*Main> :t opListe min

opListe min :: Ord a => [a] -> a

*Main> opListe min [4, 2, 3, 2.5, 7]

2.0

*Main> opListe max [4, 2, 3, 2.5, 7]

7.0

*Main> opListe (+) [4, 2, 3, 2.5, 7]

18.5

*Main> opListe (*) [4, 2, 3, 2.5, 7]

420.0

(95)

Longueur d’une liste ?

*Main> length [2,3,6,7]

4

(96)

Longueur d’une liste ?

*Main> length [2,3,6,7]

4

(97)

*Main> (opListe (+) [2,3,6,7]) / (length ^[2,3,6,7])

<interactive>:27:25:

No instance for (Fractional Int) arising from a use of ^‘/’

Possible fix: add an instance declaration for (Fractional Int) In the expression:

(opListe (+) [2, 3, 6, 7]) / (length [2, 3, 6, 7]) In an equation for ‘it’:

it = (opListe (+) [2, 3, 6, ....]) / (length ^{[2, 3, 6,} ....])

(98)

*Main> (opListe (+) [2,3,6,7]) / (length ^[2,3,6,7])

<interactive>:27:25:

No instance for (Fractional Int) arising from a use of ^‘/’

Possible fix: add an instance declaration for (Fractional Int) In the expression:

(opListe (+) [2, 3, 6, 7]) / (length [2, 3, 6, 7]) In an equation for ‘it’:

it = (opListe (+) [2, 3, 6, ....]) / (length ^{[2, 3, 6,} ....])

(99)

*Main> :t length length :: [a] -> Int

*Main> :t (/)

(/) :: Fractional a => a -> a -> a

(100)

*Main^{> :t} foldl1

foldl1 :: (a -> a -> a) -> [a] -> a

*Main^{> :t} foldl

foldl :: (a -> b -> a) -> a -> [b] -> a

(101)

longListeFrac :: (Fractional ^nb) => [patates] -> nb

longListeFrac xs = foldl (\acc patate

-> 1 + acc) 0 xs

*Main> longListeFrac [’a’..’z’]

26.0

(102)

longListeFrac :: (Fractional ^nb) => [patates] -> nb

longListeFrac xs = foldl (\acc patate

-> 1 + acc) 0 xs

*Main> longListeFrac [’a’..’z’]

26.0

(103)

Alternative récursive :

LongListeFrac :: Fractional nb => [patates] -> nb

LongListeFrac [] = 0

LongListeFrac (tete : liste_décapitée) = 1 + (LongListeFrac liste_décapitée)

(104)

m_o :: (Ord ^t, Fractional ^t) => [t] -> t

m_o liste_notes =

if nb_notes <= 0 then error "Liste trop courte !"

else

(som_notes - note_mini - note_maxi) / nb_notes

where ^{

som_notes = som_liste liste_notes ; note_mini = minListe liste_notes ; note_maxi = maxListe liste_notes ;

nb_notes = (LongListeFrac liste_notes) - 2 }

(105)

Aparté : ze Haskell Touch Définition récursive d’un type

Qu’est-ce qu’un mot ?

(106)

« glop »

:+

Vide p

o l

g

(107)

« glop »

:+

Vide p

o l

g

(108)

data ^{Mot =} Vide

| Char :+ Mot

(109)

data ^{Mot =} Vide

| Char ^{:+ Mot} deriving (Show)

(110)

data ^{Mot =} Vide

| Char ^{:+ Mot} deriving (Show, Eq)

(111)

*Main^> let m = ’g’ :+ (’l’ :+ (’o’ :+ (’p’ :+ Vide)))

*Main^{> m}

’g’ :+ (’l’ :+ (’o’ :+ (’p’ :+ Vide)))

*Main^> let m = ’g’ :+ ’l’ :+ ’o’ :+ ’p’ :+ Vide

<interactive>:44:9:

Couldn’t match expected type ‘Char’ with actual type ‘Mot’

In the first argument of ‘(:+)’, namely ’g’ :+ ’l’ :+ ’o’ :+ ’p’

In the expression: ’g’ :+ ’l’ :+ ’o’ :+ ’p’ :+ Vide

In an equation for ‘m’: m = ’g’ :+ ’l’ :+ ’o’ :+ ’p’ :+ Vide

(112)

*Main^> let m = ’g’ :+ (’l’ :+ (’o’ :+ (’p’ :+ Vide)))

*Main^{> m}

’g’ :+ (’l’ :+ (’o’ :+ (’p’ :+ Vide)))

<interactive>:44:9:

Couldn’t match expected type ‘Char’ with actual type ‘Mot’

In the first argument of ‘(:+)’, namely ’g’ :+ ’l’ :+ ’o’ :+ ’p’

In the expression: ’g’ :+ ’l’ :+ ’o’ :+ ’p’ :+ Vide

In an equation for ‘m’: m = ’g’ :+ ’l’ :+ ’o’ :+ ’p’ :+ Vide

(113)

infixr :+

data ^{Mot =} Vide

*Main> m

’g’ :+ (’l’ :+ (’o’ :+ (’p’ :+ Vide)))

(114)

infixr :+

data ^{Mot =} Vide

*Main> m

’g’ :+ (’l’ :+ (’o’ :+ (’p’ :+ Vide)))

(115)

*Main^{> m}

’g’ :+ (’l’ :+ (’o’ :+ (’p’ :+ Vide)))

*Main^{> :t m} m :: Mot

(116)

*Main^{> m}

’g’ :+ (’l’ :+ (’o’ :+ (’p’ :+ Vide)))

*Main^{> :t m} m :: Mot

(117)

Sélecteurs

tete :: Mot -> Char

−− r e n v o i e l e p r e m i e r c a r a c t è r e d ’ un mot a v e c un f i l t r a g e p a r m o t i f tete Vide = error "Mot vide !"

tete (t :+ q) = t

*Main> tete m

’g’

Et la queue ?

(118)

Sélecteurs

tete :: Mot -> Char

−− r e n v o i e l e p r e m i e r c a r a c t è r e d ’ un mot a v e c un f i l t r a g e p a r m o t i f tete Vide = error "Mot vide !"

tete (t :+ q) = t

*Main> tete m

’g’

Et la queue ?