@fmfi-uk-1-ain-412/structure-explorer 0.0.6

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { default } from './AppComponent';

package/dist/logicContext.d.ts

@@ -0,0 +1,27 @@
+import { default as React } from 'react';
+import { SymbolWithArity } from '@fmfi-uk-1-ain-412/js-fol-parser';
+export interface Formula {
+    name: string;
+    formula: string;
+}
+export interface LogicContext {
+    constants: Array<string>;
+    predicates: Array<SymbolWithArity>;
+    functions: Array<SymbolWithArity>;
+    formulas: Array<Formula>;
+    axioms: Array<Formula>;
+    theorems: Array<Formula>;
+    getFormula: (name: string) => {
+        type: string;
+        formula: string;
+    } | undefined;
+}
+export interface CellContext extends LogicContext {
+    isConstant: (symbol: string) => boolean;
+    isPredicate: (symbol: string) => boolean;
+    isFunction: (symbol: string) => boolean;
+    isVariable: (symbol: string) => boolean;
+    symbolExits: (symbol: string) => boolean;
+    symbolArity: (symbol: string) => number | undefined;
+}
+export declare const LogicContext: React.Context<CellContext | undefined>;

package/dist/main.d.ts

@@ -0,0 +1,6 @@
+import { AppComponent, prepare } from '../src/AppComponent';
+declare const _default: {
+    AppComponent: typeof AppComponent;
+    prepare: typeof prepare;
+};
+export default _default;

package/dist/model/Expression.d.ts

@@ -0,0 +1,8 @@
+import { Symbol } from './Language';
+import { DomainElement, Structure } from './Structure';
+declare abstract class Expression {
+    abstract toString(): string;
+    abstract eval(structure: Structure, e: Map<Symbol, DomainElement>): DomainElement | boolean;
+    abstract getVariables(): Set<Symbol>;
+}
+export default Expression;

package/dist/model/Language.d.ts

@@ -0,0 +1,32 @@
+import { Language as ParserLanguage } from '@fmfi-uk-1-ain-412/js-fol-parser';
+import { default as Term } from './term/Term';
+export type Symbol = string;
+export declare class Language {
+    constants: Set<Symbol>;
+    predicates: Map<Symbol, number>;
+    functions: Map<Symbol, number>;
+    constructor(constants: Set<Symbol>, predicates: Map<Symbol, number>, functions: Map<Symbol, number>);
+    /**
+     *
+     * These functions are temporarly here until the grammar changes
+     *
+     *
+     */
+    getParserLanguage(): ParserLanguage;
+    checkFunctionArity(symbol: string, args: Term[], ee: {
+        expected: (arg0: string) => void;
+    }): void;
+    checkPredicateArity(symbol: string, args: Term[], ee: {
+        expected: (arg0: string) => void;
+    }): void;
+    hasConstant(constantName: string): boolean;
+    hasPredicate(predicateName: string): boolean;
+    hasFunction(functionName: string): boolean;
+    /**
+     * Return arity of the predicate
+     * @param {string} predicateName
+     * @return {int} arity of the predicate
+     */
+    getPredicate(predicateName: string): number;
+}
+export default Language;

package/dist/model/Structure.d.ts

@@ -0,0 +1,19 @@
+import { Symbol, Language } from './Language';
+export type DomainElement = string;
+export type Valuation = Map<Symbol, DomainElement>;
+export declare class Structure {
+    language: Language;
+    domain: Set<DomainElement>;
+    iC: Map<Symbol, DomainElement>;
+    iP: Map<Symbol, Set<DomainElement[]>>;
+    iF: Map<Symbol, Map<DomainElement[], DomainElement>>;
+    /**
+     *
+     * @param {Language} language
+     */
+    constructor(language: Language, domain: Set<DomainElement>, iC: Map<Symbol, DomainElement>, iP: Map<Symbol, Set<DomainElement[]>>, iF: Map<Symbol, Map<DomainElement[], DomainElement>>);
+    iPHas(symbol: Symbol, tuple: DomainElement[]): boolean;
+    iFHas(symbol: Symbol, tuple: DomainElement[]): boolean;
+    iFGet(symbol: Symbol, tuple: DomainElement[]): DomainElement | undefined;
+}
+export default Structure;

package/dist/model/formula/Formula.Conjunction.d.ts

@@ -0,0 +1,30 @@
+import { default as Structure, Valuation } from '../Structure';
+import { default as Formula, SignedFormula, SignedFormulaType } from './Formula';
+/**
+ * Represent conjunction
+ * @author Milan Cifra
+ * @author Jozef Filip
+ * @class
+ * @extends Formula
+ */
+declare class Conjunction extends Formula {
+    subLeft: Formula;
+    subRight: Formula;
+    /**
+     *
+     * @param {Formula} subLeft
+     * @param {Formula} subRight
+     */
+    constructor(subLeft: Formula, subRight: Formula);
+    /**
+     *
+     * @param {Structure} structure
+     * @param {Map} e variables valuation
+     * @return {boolean}
+     */
+    eval(structure: Structure, e: Valuation): boolean;
+    getSubFormulas(): Formula[];
+    getSignedType(sign: boolean): SignedFormulaType;
+    getSignedSubFormulas(sign: boolean): SignedFormula[];
+}
+export default Conjunction;

package/dist/model/formula/Formula.Disjunction.d.ts

@@ -0,0 +1,30 @@
+import { default as Formula, SignedFormula, SignedFormulaType } from './Formula';
+import { default as Structure, Valuation } from '../Structure';
+/**
+ * Represent disjunction
+ * @author Milan Cifra
+ * @author Jozef Filip
+ * @class
+ * @extends Formula
+ */
+declare class Disjunction extends Formula {
+    subLeft: Formula;
+    subRight: Formula;
+    /**
+     *
+     * @param {Formula} subLeft
+     * @param {Formula} subRight
+     */
+    constructor(subLeft: Formula, subRight: Formula);
+    /**
+     *
+     * @param {Structure} structure
+     * @param {Map} e
+     * @return {boolean}
+     */
+    eval(structure: Structure, e: Valuation): boolean;
+    getSubFormulas(): Formula[];
+    getSignedType(sign: boolean): SignedFormulaType;
+    getSignedSubFormulas(sign: boolean): SignedFormula[];
+}
+export default Disjunction;

package/dist/model/formula/Formula.EqualityAtom.d.ts

@@ -0,0 +1,36 @@
+import { default as Structure, Valuation } from '../Structure';
+import { default as Term } from '../term/Term';
+import { default as Formula, SignedFormula, SignedFormulaType } from './Formula';
+/**
+ * Represent equality symbol
+ * @author Milan Cifra
+ * @author Jozef Filip
+ * @class
+ * @extends Formula
+ */
+declare class EqualityAtom extends Formula {
+    subLeft: Term;
+    subRight: Term;
+    /**
+     *
+     * @param {Term} subLeft
+     * @param {Term} subRight
+     */
+    constructor(subLeft: Term, subRight: Term);
+    /**
+     *
+     * @param {Structure} structure
+     * @param {Map} e
+     * @return {boolean}
+     */
+    eval(structure: Structure, e: Valuation): boolean;
+    /**
+     *
+     * @returns {string}
+     */
+    toString(): string;
+    getSubFormulas(): never[];
+    getSignedType(_sign: boolean): SignedFormulaType;
+    getSignedSubFormulas(_sign: boolean): SignedFormula[];
+}
+export default EqualityAtom;

package/dist/model/formula/Formula.Equivalence.d.ts

@@ -0,0 +1,35 @@
+import { default as Structure, Valuation } from '../Structure';
+import { default as Formula, SignedFormula, SignedFormulaType } from './Formula';
+/**
+ * Represent equality symbol
+ * @author Richard Toth
+ * @author Jozef Filip
+ * @class
+ * @extends Formula
+ */
+declare class Equivalence extends Formula {
+    subLeft: Formula;
+    subRight: Formula;
+    /**
+     *
+     * @param {Formula} subLeft
+     * @param {Formula} subRight
+     */
+    constructor(subLeft: Formula, subRight: Formula);
+    /**
+     *
+     * @param {Structure} structure
+     * @param {Map} e
+     * @return {boolean}
+     */
+    eval(structure: Structure, e: Valuation): boolean;
+    /**
+     *
+     * @returns {string}
+     */
+    toString(): string;
+    getSubFormulas(): Formula[];
+    getSignedType(sign: boolean): SignedFormulaType;
+    getSignedSubFormulas(sign: boolean): SignedFormula[];
+}
+export default Equivalence;

package/dist/model/formula/Formula.ExistentialQuant.d.ts

@@ -0,0 +1,29 @@
+import { default as Structure, Valuation } from '../Structure';
+import { default as Formula, SignedFormulaType } from './Formula';
+import { default as QuantifiedFormula } from './QuantifiedFormula';
+/**
+ * Represent existential quantificator
+ * @author Milan Cifra
+ * @author Jozef Filip
+ * @class
+ * @extends Formula
+ */
+declare class ExistentialQuant extends QuantifiedFormula {
+    variableName: string;
+    subFormula: Formula;
+    /**
+     *
+     * @param {string} variableName
+     * @param {Formula} subFormula
+     */
+    constructor(variableName: string, subFormula: Formula);
+    /**
+     *
+     * @param {Structure} structure
+     * @param {Map} e
+     * @return {boolean}
+     */
+    eval(structure: Structure, e: Valuation): boolean;
+    getSignedType(sign: boolean): SignedFormulaType;
+}
+export default ExistentialQuant;

package/dist/model/formula/Formula.Implication.d.ts

@@ -0,0 +1,35 @@
+import { default as Structure, Valuation } from '../Structure';
+import { default as Formula, SignedFormula, SignedFormulaType } from './Formula';
+/**
+ * Represent implication
+ * @author Milan Cifra
+ * @author Jozef Filip
+ * @class
+ * @extends Formula
+ */
+declare class Implication extends Formula {
+    subLeft: Formula;
+    subRight: Formula;
+    /**
+     *
+     * @param {Formula} subLeft
+     * @param {Formula} subRight
+     */
+    constructor(subLeft: Formula, subRight: Formula);
+    /**
+     *
+     * @param {Structure} structure
+     * @param {Map} e
+     * @return {boolean}
+     */
+    eval(structure: Structure, e: Valuation): boolean;
+    /**
+     *
+     * @returns {string}
+     */
+    toString(): string;
+    getSubFormulas(): Formula[];
+    getSignedType(sign: boolean): SignedFormulaType;
+    getSignedSubFormulas(sign: boolean): SignedFormula[];
+}
+export default Implication;

package/dist/model/formula/Formula.Negation.d.ts

@@ -0,0 +1,35 @@
+import { default as Structure, Valuation } from '../Structure';
+import { Symbol } from '../Language';
+import { default as Formula, SignedFormula, SignedFormulaType } from './Formula';
+/**
+ * Represent negation
+ * @author Milan Cifra
+ * @author Jozef Filip
+ * @class
+ * @extends Formula
+ */
+declare class Negation extends Formula {
+    subFormula: Formula;
+    /**
+     *
+     * @param {Formula} subFormula
+     */
+    constructor(subFormula: Formula);
+    /**
+     *
+     * @param {Structure} structure
+     * @param {Map} e
+     * @return {boolean}
+     */
+    eval(structure: Structure, e: Valuation): boolean;
+    /**
+     *
+     * @returns {string}
+     */
+    toString(): string;
+    getSubFormulas(): Formula[];
+    getVariables(): Set<Symbol>;
+    getSignedType(_: boolean): SignedFormulaType;
+    getSignedSubFormulas(sign: boolean): SignedFormula[];
+}
+export default Negation;

package/dist/model/formula/Formula.PredicateAtom.d.ts

@@ -0,0 +1,37 @@
+import { default as Formula, SignedFormula, SignedFormulaType } from './Formula';
+import { default as Term } from '../term/Term';
+import { default as Structure, Valuation } from '../Structure';
+/**
+ * Represent predicate symbol
+ * @author Milan Cifra
+ * @author Jozef Filip
+ * @class
+ * @extends Formula
+ */
+declare class PredicateAtom extends Formula {
+    name: string;
+    terms: Term[];
+    /**
+     *
+     * @param {string} name
+     * @param {Term[]} terms
+     */
+    constructor(name: string, terms?: Term[]);
+    depth(): number;
+    /**
+     *
+     * @param {Structure} structure
+     * @param {Map} e
+     * @return {boolean}
+     */
+    eval(structure: Structure, e: Valuation): boolean;
+    /**
+     *
+     * @returns {string}
+     */
+    toString(): string;
+    getSubFormulas(): Formula[];
+    getSignedType(_: boolean): SignedFormulaType;
+    getSignedSubFormulas(_: boolean): SignedFormula[];
+}
+export default PredicateAtom;

package/dist/model/formula/Formula.UniversalQuant.d.ts

@@ -0,0 +1,29 @@
+import { default as Structure, Valuation } from '../Structure';
+import { default as Formula, SignedFormulaType } from './Formula';
+import { default as QuantifiedFormula } from './QuantifiedFormula';
+/**
+ * Represent universal quantificator
+ * @author Milan Cifra
+ * @author Jozef Filip
+ * @class
+ * @extends Formula
+ */
+declare class UniversalQuant extends QuantifiedFormula {
+    variableName: string;
+    subFormula: Formula;
+    /**
+     *
+     * @param {string} variableName
+     * @param {Formula} subFormula
+     */
+    constructor(variableName: string, subFormula: Formula);
+    /**
+     *
+     * @param {Structure} structure
+     * @param {Map} e
+     * @return {boolean}
+     */
+    eval(structure: Structure, e: Valuation): boolean;
+    getSignedType(sign: boolean): SignedFormulaType;
+}
+export default UniversalQuant;

package/dist/model/formula/Formula.d.ts

@@ -0,0 +1,37 @@
+import { default as Expression } from '../Expression';
+import { Symbol } from '../Language';
+import { Structure, Valuation } from '../Structure';
+export declare enum SignedFormulaType {
+    ALPHA = "alpha",
+    BETA = "beta",
+    GAMMA = "gamma",
+    DELTA = "delta"
+}
+export type SignedFormula = {
+    sign: boolean;
+    formula: Formula;
+};
+/**
+ * Represent simple formula
+ * @author Milan Cifra
+ * @author Jozef Filip
+ * @class
+ * @abstract
+ * @extends Expression
+ */
+declare abstract class Formula extends Expression {
+    protected subFormulas: Formula[];
+    protected connective: string;
+    constructor(subFormulas: Formula[], connective: string);
+    getSubFormulas(): Formula[];
+    toString(): string;
+    gameDepth(sign: boolean): number;
+    signedFormulaToString(sign: boolean): string;
+    depth(): number;
+    winningSubformulas(sign: boolean, structure: Structure, e: Valuation): SignedFormula[];
+    abstract eval(structure: Structure, e: Valuation): boolean;
+    getVariables(): Set<Symbol>;
+    abstract getSignedType(sign: boolean): SignedFormulaType;
+    abstract getSignedSubFormulas(sign: boolean): SignedFormula[];
+}
+export default Formula;

package/dist/model/formula/QuantifiedFormula.d.ts

@@ -0,0 +1,18 @@
+import { default as Structure, DomainElement, Valuation } from '../Structure';
+import { default as Formula, SignedFormula, SignedFormulaType } from './Formula';
+import { Symbol } from '../Language';
+declare abstract class QuantifiedFormula extends Formula {
+    variableName: string;
+    subFormula: Formula;
+    connective: string;
+    constructor(variableName: string, subFormula: Formula, connective: string);
+    abstract eval(structure: Structure, e: Valuation): boolean;
+    abstract getSignedType(sign: boolean): SignedFormulaType;
+    getSignedSubFormulas(sign: boolean): SignedFormula[];
+    toString(): string;
+    getVariableName(): string;
+    winningElements(sign: boolean, structure: Structure, e: Valuation): DomainElement[];
+    getVariables(): Set<Symbol>;
+    getSubFormulas(): Formula[];
+}
+export default QuantifiedFormula;

package/dist/model/term/Term.Constant.d.ts

@@ -0,0 +1,32 @@
+import { default as Structure, DomainElement, Valuation } from '../Structure';
+import { Symbol } from '../Language';
+import { default as Term } from './Term';
+/**
+ * Constant
+ * @author Milan Cifra
+ * @author Jozef Filip
+ * @class
+ * @extends Term
+ */
+declare class Constant extends Term {
+    name: string;
+    /**
+     *
+     * @param {string} name Name of the constant
+     */
+    constructor(name: string);
+    /**
+     * Return intepretation of the constant
+     * @param {Structure} structure Structure
+     * @param {Map} e variables valuation
+     * @return {string} domain item
+     */
+    eval(structure: Structure, _: Valuation): DomainElement;
+    /**
+     * Return string representation of constant
+     * @returns {string}
+     */
+    toString(): string;
+    getVariables(): Set<Symbol>;
+}
+export default Constant;

package/dist/model/term/Term.FunctionTerm.d.ts

@@ -0,0 +1,34 @@
+import { default as Structure, DomainElement, Valuation } from '../Structure';
+import { Symbol } from '../Language';
+import { default as Term } from './Term';
+/**
+ * Represent function term
+ * @author Milan Cifra
+ * @author Jozef Filip
+ * @class
+ * @extends Term
+ */
+declare class FunctionTerm extends Term {
+    name: string;
+    terms: Term[];
+    /**
+     *
+     * @param {string} name name of the function
+     * @param {Term[]} terms parameters of function
+     */
+    constructor(name: string, terms: Term[]);
+    /**
+     * Return intepretation of function.
+     * @param {Structure} structure
+     * @param {Map} e variables valuation
+     * @returns {string} domain item
+     */
+    eval(structure: Structure, e: Valuation): DomainElement;
+    /**
+     * Return string representation of function term
+     * @returns {string}
+     */
+    toString(): string;
+    getVariables(): Set<Symbol>;
+}
+export default FunctionTerm;

package/dist/model/term/Term.Variable.d.ts

@@ -0,0 +1,33 @@
+import { Symbol } from '../Language';
+import { Structure, Valuation, DomainElement } from '../Structure';
+import { default as Term } from './Term';
+/**
+ * Variable
+ * @author Milan Cifra
+ * @author Jozef Filip
+ * @class
+ * @extends Term
+ */
+declare class Variable extends Term {
+    name: Symbol;
+    /**
+     *
+     * @param {string} name
+     */
+    constructor(name: Symbol);
+    /**
+     * Return intepretation of variable.
+     * @param {Structure} structure
+     * @param {Map} e variables valuation
+     * @return {DomainElement} domain item
+     */
+    eval(_: Structure, e: Valuation): DomainElement;
+    /**
+     * Return string representation of variable
+     * @returns {DomainElement}
+     */
+    toString(): DomainElement;
+    createCopy(): Variable;
+    getVariables(): Set<Symbol>;
+}
+export default Variable;

package/dist/model/term/Term.d.ts

@@ -0,0 +1,15 @@
+import { default as Expression } from '../Expression';
+import { Symbol } from '../Language';
+import { default as Structure, DomainElement } from '../Structure';
+/**
+ * Represent simple term.
+ * @author Milan Cifra
+ * @author Jozef Filip
+ * @class
+ * @abstract
+ *
+ */
+declare abstract class Term extends Expression {
+    abstract eval(structure: Structure, e: Map<Symbol, DomainElement>): DomainElement;
+}
+export default Term;