public static void ShouldHaveState(
     this CNFClause <MyModel> clause,
     bool isDefiniteClause,
     bool isGoalClause,
     bool isHornClause,
     bool isUnitClause,
     int literalCount)
 {
     Assert.Equal(isDefiniteClause, clause.IsDefiniteClause);
     Assert.Equal(isGoalClause, clause.IsGoalClause);
     Assert.Equal(isHornClause, clause.IsHornClause);
     Assert.Equal(isUnitClause, clause.IsUnitClause);
     Assert.Equal(literalCount, clause.Literals.Count);
 }
        /// <summary>
        /// Resolves to clauses to create a new clause - eliminating any mutually-negating literals (and any duplicates) in the process.
        /// </summary>
        /// <param name="clause1"></param>
        /// <param name="clause2"></param>
        /// <returns>A new clause.</returns>
        public static CNFClause <TModel> Resolve(CNFClause <TModel> clause1, CNFClause <TModel> clause2)
        {
            var literals = new List <PLLiteral <TModel> >();

            // TODO-PERFORMANCE: There are myriad ways to improve performance here. Sorting literals in clauses is one..
            foreach (var l1 in clause1.Literals)
            {
                foreach (var l2 in clause2.Literals)
                {
                    // TODO
                }
            }

            return(new CNFClause <TModel>(literals));
        }
 public ClauseExaminer(CNFClause <TModel> owner, List <PLLiteral <TModel> > literals) => (this.owner, this.literals) = (owner, literals);