Diagnostic d’un réseau par abduction explicite¶

from .disjonction import Disjonction
from .conjonction import Conjonction

class Abduction:

    def __init__(self, conflits, no_goods):
        self.conflits = conflits
        self.no_goods = no_goods

    def combiner_conflits_observations(self, disjonctions):
        """ Combine plusieurs disjonctions en une seule.

            :param disjonctions: une collection de disjonctions.
        """
        combinaison = Disjonction()
        for disjonction in disjonctions:
            combinaison = combinaison.combiner(disjonction)
        return combinaison

    def retire_subsumes(self, conjonctions):
        """ Retire d'une liste de conjonctions les candidats
            subsumés.

            :param conjonctions: une liste de conjonctions.
        """
        sans_subsumes = Disjonction()

        for conjonction in sorted(conjonctions, key=lambda expl: len(expl)):
            conserver = True
            for conj in sans_subsumes:
                if conj.issubset(conjonction):
                    conserver = False
                    break
            if conserver:
                sans_subsumes.add(conjonction)

        return sans_subsumes

    def retire_no_goods(self, conjonctions, no_goods):
        """
            Retire d'une liste de conjonctions les candidats
            contenant un no-good.

            Les conjonctions résultantes sont retournées sous
            forme de disjonction.

            :param conjonctions: une collection de conjonctions.
            :param no_goods: une liste de no-goods.
        """
        sans_no_goods = Disjonction()

        for conjonction in conjonctions:
            conserver = True
            for no_good in no_goods:
                if no_good.issubset(conjonction):
                    conserver = False
                    break
            if conserver:
                sans_no_goods.add(conjonction)

        return sans_no_goods

    def calcule_conflit_minimal(self, afficher_etapes=False):
        """
            Calcule par abduction le conflit minimal entre les candidats.
        """

        # 1. Combine les conflits.
        conflit_minimal = self.combiner_conflits_observations(self.conflits)
        if afficher_etapes: print('Conflit combiné :', conflit_minimal)

        # 3. Supprime les candidats subsumés.
        conflit_minimal = self.retire_subsumes(conflit_minimal)
        if afficher_etapes: print('Non subsumés :', conflit_minimal)

        # 4. Supprime les candidats contenant les no-goods.
        conflit_minimal = self.retire_no_goods(conflit_minimal, self.no_goods)
        if afficher_etapes: print('Sans no-goods :', conflit_minimal)

        return conflit_minimal