Mathématiques avec Python et Ruby/Ensembles en Ruby

Les évènements sont décrits en probabilité par des ensembles. Si ces ensembles sont finis, Ruby les gère.

Construction d'évènements

modifier

Évènements certain et impossible

modifier

L'évènement impossible, noté  , est entré en Ruby avec des crochets vides:

impossible=[]
puts(impossible.length())
puts(impossible.empty?)

L'ensemble de toutes les issues possibles de l'expérience aléatoire, appelé univers, est noté  .

Pour savoir si un élément se trouve dans un ensemble, on utilise include? comme dans omega.include?(6) pour savoir si l'évènement peut donner un 6.

Avec un dé

modifier
 

On s'apprête à lancer un dé. Alors l'évènement "le résultat sera plus petit que 5" est décrit par l'ensemble  . De même, l'évènement "le résultat sera pair" est représenté par  . On construit aisément ces évènements avec la notation ensembliste de Ruby qui se fait avec des crochets au lieu des accolades. Mais la définition d'ensembles par description est possible avec Ruby:

univers=(1..6).to_a
petit=univers.select { |r| r<5 }
pair=univers.select { |r| r%2==0 }
impossible=[]

Pour construire l'univers, on peut prend la liste des nombres allant de 1 à 6, et on la transforme en tableau avec to_a. Pour avoir les petits résultats (moins que 5), on choisit dans l'univers les éléments qui sont inférieurs à 5. select est une méthode de l'objet univers, qui se crée une variable r (entre traits verticaux) et lui fait parcourir les éléments du tableau (car univers en est un) et lui fait passer ou non par un filtre. En bref, on sélectionne les éléments de l'univers qui sont inférieurs à 5. De même, pour avoir les résultats pairs, on sélectionne les éléments de l'univers dont le quotient par 2 tombe juste (reste nul).

Avec des cartes

modifier
 

Cette fois-ci, on extrait au hasard une carte parmi un jeu de 32 cartes.

On construit l'univers par un produit cartésien (des cartes avec Descartes !) entre l'ensemble des valeurs et celui des couleurs:

valeurs=[1,7,8,9,10,'Valet','Dame','Roi']
couleurs=['carreau','cœur','pique','trèfle']
valeurs=valeurs.collect { |v| v.to_s }
univers=[]
valeurs.collect { |v| couleurs.collect { |c| univers.push(v+' '+c) }}
puts(univers)

La troisième ligne transforme toutes les cartes en chaînes de caractères; en effet certaines d'entre elles étaient des chiffres. La suite du script consiste à créer un univers initialement vide, puis, avec la méthode collect du tableau des valeurs de cartes, à placer dans le jeu de cartes, l'une après l'autre, toutes les cartes (il est nécessaire de mettre une boucle à l'intérieur de la première, pour les différentes couleurs associées à chaque valeur de carte).

 

L'évènement "la carte est une figure" (pas un nombre) se construit en choisissant les cartes dont le début du nom n'est pas un nombre entier (donc se transforme en 0 lorsqu'on le convertit en entier):

figure=univers.select { |carte| carte[0..1].to_i==0 }
puts(figure)

Et pour construire l'évènement "la carte est un pique", on extrait les cartes de pique du jeu entier:

pique=univers.select { |carte| carte[-2..-1]=='ue'}
puts(pique)

(on extrait les cartes dont le nom termine par ue, puisque seul le mot pique se termine ainsi).

Évènements simultanés

modifier

Notation

modifier

L'évènement "A et B" se note  , et l'opération se note en Ruby par une esperluette (&).

Avec le dé

modifier
petit=[1,2,3,4]
pair=[2,4,6]
puts(petit&pair)

Avec les cartes

modifier

Le script suivant montre que dans un jeu de 32 cartes, il y en a 3 qui sont à la fois des figures et des piques: Les trois figures de pique:

puts(figure&pique)


Le "ou" inclusif

modifier

Notation

modifier

De même l'évènement "A ou B" se note  , et en Ruby, le symbole pipe (trait vertical). Ruby enlève automatiquement les doublons.

Avec le dé

modifier
petit=[1,2,3,4]
pair=[2,4,6]
puts(petit|pair)

Avec les cartes

modifier

On peut compter les cartes qui sont des figures ou des piques:

puts(figure|pique)
puts((figure|pique).size)

...mais on peut aussi laisser Ruby les compter, il en trouve 17. Ce comptage est à la base des calculs de probabilité.

Contraire

modifier

Pour calculer le contraire d'un évènement, on le soustrait à l'univers.

Avec le dé

modifier
univers=[1,2,3,4,5,6]
petit=[1,2,3,4]
pair=[2,4,6]
puts(univers-petit)
puts(univers-pair)

Ce qui montre que le contraire de "pair" est "impair".

Avec les cartes

modifier
puts(univers-figure)
puts(univers-pique)

Probabilités

modifier

La probabilité d'un évènement est définie comme le quotient de sa taille (en Ruby, size) par celle de l'univers.

On peut associer une probabilité à un évènement seul, en baptisant l'univers $univers ce qui fait qu'il est une variable globale, et en définissant une probabilité par

require 'mathn'
def proba(e)
    return Rational(e.size,$univers.size)
end

Mais pour éviter l'usage d'une variable globale, on peut aussi associer une probabilité à l'évènement et à son univers:


Avec le dé

modifier
require 'mathn'
univers=[1,2,3,4,5,6]
petit=[1,2,3,4]
pair=[2,4,6]
puts(Rational(petit.size,univers.size))
puts(Rational(pair.size,univers.size))


def proba(e,u)
    return Rational(e.size,u.size)
end

p1=proba(petit,univers)+proba(pair,univers)-proba(petit&pair,univers)
puts(p1)
p2=proba(petit|pair,univers)
puts(p1==p2)


Avec les cartes

modifier
require 'mathn'

puts(Rational(figure.size,univers.size))
puts(Rational(pique.size,univers.size))


def proba(e,u)
    return Rational(e.size,u.size)
end

p1=proba(figure,univers)+proba(pique,univers)-proba(figure&pique,univers)
puts(p1)
p2=proba(figure|pique,univers)
puts(p1==p2)

Probabilités conditionnelles

modifier

Ci-dessus, on a défini les probabilités avec comme paramètre l'univers. En effet, cette variable est globale, donc inaccessible a priori dans le corps de la fonction. Ceci permet de remplacer l'univers par un autre évènement, et donc de définir la probabilité conditionnelle. Par exemple, avec le dé:

require 'mathn'
univers=[1,2,3,4,5,6]
petit=[1,2,3,4]
pair=[2,4,6]

def proba(e,u)
    return Rational(e.size,u.size)
end

p1=proba(petit&pair,petit)
puts(p1)
p2=proba(petit&pair,pair)
puts(p1==p2)

Définitions

modifier

On peut alors définir des booléens concernant des évènements, en utilisant les propriétés de leurs probabilités:

require 'mathn'

def incompatibles(a,b)
    return proba(a&b)==0
end


def indépendants(a,b)
    return proba(a&b)==proba(a)*proba(b)
end