AIMA.Core.Logic.FOL.NegationsIn.visitNotSentence C# (CSharp) Метод

        public Object visitNotSentence(NotSentence notSentence, Object arg)
        {
            // CNF requires NOT (~) to appear only in literals, so we 'move ~
            // inwards' by repeated application of the following equivalences:
            Sentence negated = notSentence.getNegated();

            // ~(~alpha) equivalent to alpha (double negation elimination)
            if (negated is NotSentence)
            {
                return ((NotSentence)negated).getNegated().accept(this, arg);
            }

            if (negated is ConnectedSentence)
            {
                ConnectedSentence negConnected = (ConnectedSentence)negated;
                Sentence alpha = negConnected.getFirst();
                Sentence beta = negConnected.getSecond();
                // ~(alpha ^ beta) equivalent to (~alpha V ~beta) (De Morgan)
                if (Connectors.isAND(negConnected.getConnector()))
                {
                    // I need to ensure the ~s are moved in deeper
                    Sentence notAlpha = (Sentence)(new NotSentence(alpha)).accept(
                            this, arg);
                    Sentence notBeta = (Sentence)(new NotSentence(beta)).accept(
                            this, arg);
                    return new ConnectedSentence(Connectors.OR, notAlpha, notBeta);
                }

                // ~(alpha V beta) equivalent to (~alpha ^ ~beta) (De Morgan)
                if (Connectors.isOR(negConnected.getConnector()))
                {
                    // I need to ensure the ~s are moved in deeper
                    Sentence notAlpha = (Sentence)(new NotSentence(alpha)).accept(
                            this, arg);
                    Sentence notBeta = (Sentence)(new NotSentence(beta)).accept(
                            this, arg);
                    return new ConnectedSentence(Connectors.AND, notAlpha, notBeta);
                }
            }

            // in addition, rules for negated quantifiers:
            if (negated is QuantifiedSentence)
            {
                QuantifiedSentence negQuantified = (QuantifiedSentence)negated;
                // I need to ensure the ~ is moved in deeper
                Sentence notP = (Sentence)(new NotSentence(negQuantified
                        .getQuantified())).accept(this, arg);

                // ~FORALL x p becomes EXISTS x ~p
                if (Quantifiers.isFORALL(negQuantified.getQuantifier()))
                {
                    return new QuantifiedSentence(Quantifiers.EXISTS, negQuantified
                            .getVariables(), notP);
                }

                // ~EXISTS x p becomes FORALL x ~p
                if (Quantifiers.isEXISTS(negQuantified.getQuantifier()))
                {
                    return new QuantifiedSentence(Quantifiers.FORALL, negQuantified
                            .getVariables(), notP);
                }
            }

            return new NotSentence((Sentence)negated.accept(this, arg));
        }