Les évènements sont décrits en probabilité par des ensembles. Si ces ensembles sont finis, "Ruby" les gère.
=Construction d'évènements=
Évènements certain et impossible.
L'évènement impossible, noté formula_1, 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é formula_2.
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é.
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 formula_3. De même, l'évènement "le résultat sera pair" est représenté par formula_4. 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
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.
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']
univers=[]
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):
puts(figure)
Et pour construire l'évènement "la carte est un pique", on extrait les cartes de pique du jeu entier:
puts(pique)
(on extrait les cartes dont le nom termine par "ue", puisque seul le mot "pique" se termine ainsi).
Évènements simultanés.
Notation.
L'évènement "A et B" se note formula_5, et l'opération se note en "Ruby" par une esperluette ("&").
Avec le dé.
petit=[1,2,3,4]
pair=[2,4,6]
puts(petit&pair)
Avec les cartes.
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.
Notation.
De même l'évènement "A ou B" se note formula_6, et en "Ruby", le symbole "pipe" (trait vertical). "Ruby" enlève automatiquement les doublons.
Avec le dé.
petit=[1,2,3,4]
pair=[2,4,6]
puts(petit|pair)
Avec les cartes.
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.
Pour calculer le contraire d'un évènement, on le soustrait à l'univers.
Avec le dé.
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.
puts(univers-figure)
puts(univers-pique)
=Probabilités=
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é.
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.
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.
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.
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

Mathématiques avec Python et Ruby/Ensembles en Python