tfl-js/dist/cjs/evaluator/index.js

A TypeScript library for parsing and evaluating propositional logic formulas

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Evaluator = void 0;
class Evaluator {
    /**
     * Generate all possible valuations for a set of atomic propositions
     */
    generateValuations(atoms) {
        const valuations = [];
        const numValuations = Math.pow(2, atoms.length);
        const sortedAtoms = [...atoms].sort();
        for (let i = numValuations - 1; i >= 0; i--) {
            const valuation = {};
            for (let j = 0; j < sortedAtoms.length; j++) {
                // Use bit operations to generate all possible combinations
                valuation[sortedAtoms[j]] = !!(i & (1 << j));
            }
            valuations.push(valuation);
        }
        return valuations;
    }
    /**
     * Check if a formula is a tautology (true under all valuations)
     */
    isTautology(formula) {
        const atoms = formula.atoms();
        const valuations = this.generateValuations(atoms);
        return valuations.every(valuation => formula.evaluate(valuation));
    }
    /**
     * Check if a formula is a contradiction (false under all valuations)
     */
    isContradiction(formula) {
        const atoms = formula.atoms();
        const valuations = this.generateValuations(atoms);
        return valuations.every(valuation => !formula.evaluate(valuation));
    }
    /**
     * Check if a formula is contingent (neither a tautology nor a contradiction)
     */
    isContingent(formula) {
        const atoms = formula.atoms();
        const valuations = this.generateValuations(atoms);
        return valuations.some(valuation => formula.evaluate(valuation)) &&
            valuations.some(valuation => !formula.evaluate(valuation));
    }
    /**
     * Check if two formulas are logically equivalent
     */
    areEquivalent(formula1, formula2) {
        // Get all atoms from both formulas
        const atoms = [...new Set([...formula1.atoms(), ...formula2.atoms()])];
        const valuations = this.generateValuations(atoms);
        // Check if formulas have same truth value under all valuations
        return valuations.every(valuation => formula1.evaluate(valuation) === formula2.evaluate(valuation));
    }
    /**
     * Find all valuations that make the formula true
     */
    findSatisfyingValuations(formula) {
        const atoms = formula.atoms();
        const valuations = this.generateValuations(atoms);
        return valuations.filter(valuation => formula.evaluate(valuation));
    }
    /**
     * Check if formula1 logically entails formula2
     */
    isValidConsequence(premise, conclusion) {
        // Get all atoms from both formulas
        const atoms = [...new Set([...premise.atoms(), ...conclusion.atoms()])];
        const valuations = this.generateValuations(atoms);
        // Check if every valuation that makes premise true also makes conclusion true
        return valuations.every(valuation => !premise.evaluate(valuation) || conclusion.evaluate(valuation));
    }
}
exports.Evaluator = Evaluator;
//# sourceMappingURL=index.js.map