public override Formula Simplify()
        {
            Formula fSimplified = null;
            if (Simplified)
                return this;
            if( Operator == "not" )
                fSimplified = Negate();
            if (Operands.Count == 1)
                fSimplified = Operands[0].Simplify();
            if (Operator == "when")
            {
                CompoundFormula cfNew = new CompoundFormula(Operator);
                Formula fFirst = Operands[0].Simplify();
                Formula fSecond = Operands[1].Simplify();

                cfNew.SimpleAddOperand(fFirst);

                if (IsSimpleAnd(fFirst) && IsSimpleAnd(fSecond))
                {
                    HashSet<Predicate> lFirst = fFirst.GetAllPredicates();
                    HashSet<Predicate> lSecond = fSecond.GetAllPredicates();
                    CompoundFormula cfSecond = new CompoundFormula("and");
                    foreach (Predicate p in lSecond)
                        if (!lFirst.Contains(p))
                            cfSecond.AddOperand(p);
                    cfNew.SimpleAddOperand(cfSecond);
                }
                else
                {
                    cfNew.SimpleAddOperand(fSecond);
                }
                cfNew.Simplified = true;
                fSimplified = cfNew;
            }
            else if (Operator == "and" || Operator == "or" || Operator == "oneof")
            {
                /*
                if (Operands.Count == 0)
                {
                    if (Operator == "and")
                        return new PredicateFormula(new GroundedPredicate(Domain.TRUE_PREDICATE));
                    if (Operator == "or" || Operator == "oneof")
                        return new PredicateFormula(new GroundedPredicate(Domain.FALSE_PREDICATE));
                }
                 * */
                CompoundFormula cfNew = new CompoundFormula(Operator);
                foreach (Formula f in Operands)
                {
                    Formula fSimplify = f.Simplify();
                    if (fSimplify is CompoundFormula)
                    {
                        CompoundFormula cf = (CompoundFormula)fSimplify;
                        if (cf.Operator == Operator)
                        {
                            foreach (Formula ff in cf.Operands)
                                cfNew.AddOperand(ff);
                        }
                        else
                            cfNew.AddOperand(cf);
                    }
                    else if (fSimplify is ProbabilisticFormula)
                    {
                        cfNew.AddOperand(fSimplify);
                    }
                    else
                    {
                        Predicate p = ((PredicateFormula)fSimplify).Predicate;
                        if (p.Name == Domain.TRUE_PREDICATE)
                        {
                            if (Operator == "or")
                                return fSimplify;
                        }
                        else if (p.Name == Domain.FALSE_PREDICATE)
                        {
                            if (Operator == "and")
                                return fSimplify;
                        }
                        else
                            cfNew.AddOperand(fSimplify);
                    }
                }
                if (cfNew.Operands.Count == 1)
                    return cfNew.Operands[0];
                if (cfNew.Operator == "or")
                    cfNew = cfNew.RemoveRedundancies();
                fSimplified = cfNew;
            }
            if( fSimplified is CompoundFormula )
                ((CompoundFormula)fSimplified).Simplified = true;
            return fSimplified;
        }