Variable ChopLogicCoreConst

ChopLogicCore: Readonly<
    {
        HilbertCalculus: Readonly<
            {
                generateStep: <T>(input: HilbertProofStepInput<T>) => PropProofStep;
                ID: (formulas: PropFormula[]) => PropFormula;
                IE: (formulas: PropFormula[]) => PropFormula;
                II: (formulas: PropFormula[]) => PropFormula;
                IR: (formulas: PropFormula[]) => PropFormula;
            },
        >;
        NaturalCalculus: Readonly<
            {
                CE: (formulas: PropFormula[]) => PropFormula[];
                CI: (formulas: PropFormula[]) => [PropFormula, PropFormula];
                DE: (formulas: PropFormula[]) => [PropFormula];
                DI: (formulas: PropFormula[]) => [PropFormula, PropFormula];
                EE: (formulas: PropFormula[]) => PropFormula[];
                EI: (formulas: PropFormula[]) => [PropFormula];
                generateSteps: <T>(input: NaturalProofStepInput<T>) => PropProofStep[];
                IE: (formulas: PropFormula[]) => [PropFormula];
                II: (formulas: PropFormula[]) => [PropFormula];
                NE: (formulas: PropFormula[]) => [PropFormula];
                NI: (formulas: PropFormula[]) => [PropFormula];
            },
        >;
        PropositionalFactory: Readonly<
            {
                createExpression: (input: string) => PropSymbol[];
                createFormula: (expression: PropExpression) => PropFormula;
                createOperator: (symbol: PropSymbol) => Operator;
                createSymbol: (char: string, position: number) => PropSymbol;
            },
        >;
        PropositionalUtils: Readonly<
            {
                applyChecks: (
                    formulas: PropFormula[],
                    checks?: PropFormulaCheck[],
                ) => Record<PropFormulaCheck, boolean>;
                calculateFormula: (
                    params: {
                        assignment: boolean[];
                        formula: PropFormula;
                        variablesMap?: PropFormulaVariablesMap;
                    },
                ) => boolean;
                convertToExpression: (formula: PropFormula) => PropExpression;
                convertToString: (formula: PropFormula) => string;
                generateAssignments: (
                    varCount: number,
                    limit?: number,
                ) => TruthAssignmentsMap;
                generateTT: (
                    formula: PropFormula,
                    limit?: number,
                ) => TruthAssignmentsMap;
                getBinaryValue: (
                    __namedParameters: {
                        leftOperand: boolean;
                        operator: Operator;
                        rightOperand: boolean;
                    },
                ) => boolean;
                getSubFormulas: (formula: PropFormula) => PropFormula[];
                getUnaryValue: (
                    __namedParameters: { operand: boolean; operator: Operator },
                ) => boolean;
                getVariables: (formula: PropFormula) => PropFormulaVariablesMap;
                isWFF: (expression: PropExpression) => boolean;
            },
        >;
        Tokenizer: Readonly<
            {
                getGlyphUnicode: (char: string) => GlyphUnicode;
                getOperatorGlyph: (operator: Operator) => Glyph;
                tokenizeString: (input: string) => string[];
            },
        >;
    },
> = ...