2021-05-14 19:23:53 +02:00
|
|
|
package formulae
|
|
|
|
|
2021-05-18 11:31:29 +02:00
|
|
|
import "logik/core/utils"
|
|
|
|
|
2021-05-14 19:23:53 +02:00
|
|
|
/* ---------------------------------------------------------------- *
|
|
|
|
* METHOD Get Atoms
|
|
|
|
* ---------------------------------------------------------------- */
|
|
|
|
|
|
|
|
func schemeGetAtoms(fml Formula, prevValues [](*[]Formula)) *[]Formula {
|
|
|
|
if fml.IsAtom() {
|
|
|
|
return &[]Formula{fml.Copy()}
|
|
|
|
} else {
|
|
|
|
var results = []Formula{}
|
|
|
|
for _, prevValue := range prevValues {
|
|
|
|
results = append(results, *prevValue...)
|
|
|
|
}
|
|
|
|
return &results
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
var fnGetAtoms = CreateFromSchemeFmlsValued(schemeGetAtoms)
|
|
|
|
|
|
|
|
func (fml Formula) GetAtoms() []Formula {
|
|
|
|
return *fnGetAtoms(fml)
|
|
|
|
}
|
2021-05-18 11:31:29 +02:00
|
|
|
|
|
|
|
/* ---------------------------------------------------------------- *
|
|
|
|
* TYPE FormulaPair, FormulaPairs
|
|
|
|
* ---------------------------------------------------------------- */
|
|
|
|
|
|
|
|
type FormulaPair struct {
|
|
|
|
Pos Formula
|
|
|
|
Neg Formula
|
|
|
|
}
|
|
|
|
|
|
|
|
type FormulaPairs []FormulaPair
|
|
|
|
|
|
|
|
/* ---------------------------------------------------------------- *
|
|
|
|
* Methods for FormulaPairs
|
|
|
|
* ---------------------------------------------------------------- */
|
|
|
|
|
|
|
|
func NewFormulaPairs(pairs []FormulaPair) FormulaPairs { return pairs }
|
|
|
|
|
|
|
|
func (pairs FormulaPairs) Pos() []Formula {
|
|
|
|
var fmls = make([]Formula, len(pairs))
|
|
|
|
for i, pair := range pairs {
|
|
|
|
fmls[i] = pair.Pos
|
|
|
|
}
|
|
|
|
return fmls
|
|
|
|
}
|
|
|
|
|
|
|
|
func (pairs FormulaPairs) Neg() []Formula {
|
|
|
|
var fmls = make([]Formula, len(pairs))
|
|
|
|
for i, pair := range pairs {
|
|
|
|
fmls[i] = pair.Neg
|
|
|
|
}
|
|
|
|
return fmls
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ---------------------------------------------------------------- *
|
|
|
|
* TYPE KNF, DNF, Horn
|
|
|
|
* ---------------------------------------------------------------- */
|
|
|
|
|
|
|
|
type FormulaConjunct []Formula
|
|
|
|
type FormulaDisjunct []Formula
|
|
|
|
type FormulaKNF []FormulaDisjunct
|
|
|
|
type FormulaDNF []FormulaConjunct
|
|
|
|
type FormulaHornClause struct {
|
|
|
|
Pos FormulaDisjunct
|
|
|
|
Neg FormulaConjunct
|
|
|
|
}
|
|
|
|
type FormulaHorn []FormulaHornClause
|
|
|
|
|
|
|
|
/* ---------------------------------------------------------------- *
|
|
|
|
* Methods for KNF, DNF, Horn
|
|
|
|
* ---------------------------------------------------------------- */
|
|
|
|
|
|
|
|
func (fml FormulaDisjunct) ToFormula() Formula {
|
|
|
|
return Disjunction(fml)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (fml FormulaConjunct) ToFormula() Formula {
|
|
|
|
return Conjunction(fml)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (fml FormulaKNF) ToFormula() Formula {
|
|
|
|
var termsAsFormulae = make([]Formula, len(fml))
|
|
|
|
for i, term := range fml {
|
|
|
|
termsAsFormulae[i] = term.ToFormula()
|
|
|
|
}
|
|
|
|
return Conjunction(termsAsFormulae)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (fml FormulaDNF) ToFormula() Formula {
|
|
|
|
var termsAsFormulae = make([]Formula, len(fml))
|
|
|
|
for i, term := range fml {
|
|
|
|
termsAsFormulae[i] = term.ToFormula()
|
|
|
|
}
|
|
|
|
return Disjunction(termsAsFormulae)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (fml FormulaHornClause) ToFormula() Formula {
|
|
|
|
return Implies(fml.Neg.ToFormula(), fml.Pos.ToFormula())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (fml FormulaHorn) ToFormula() Formula {
|
|
|
|
var hornclausesAsFormulae = make([]Formula, len(fml))
|
|
|
|
for i, hornclause := range fml {
|
|
|
|
hornclausesAsFormulae[i] = hornclause.ToFormula()
|
|
|
|
}
|
|
|
|
return Conjunction(hornclausesAsFormulae)
|
|
|
|
}
|
|
|
|
|
|
|
|
func getAtomsFromArrayOfLiterals(fmls []Formula) []string {
|
|
|
|
var atoms = []string{}
|
|
|
|
var m = map[string]bool{}
|
|
|
|
for _, fml := range fmls {
|
|
|
|
if fml.IsLiteral() {
|
|
|
|
m[fml.GetName()] = true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for name, _ := range m {
|
|
|
|
atoms = append(atoms, name)
|
|
|
|
}
|
|
|
|
utils.SortStrings(&atoms)
|
|
|
|
return atoms
|
|
|
|
}
|
|
|
|
|
|
|
|
func getAtomsFromArrayOfArraysOfLiterals(fmlArrays [][]Formula) []string {
|
|
|
|
var atoms = []string{}
|
|
|
|
var m = map[string]bool{}
|
|
|
|
for _, fmls := range fmlArrays {
|
|
|
|
for _, atom := range getAtomsFromArrayOfLiterals(fmls) {
|
|
|
|
m[atom] = true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for name, _ := range m {
|
|
|
|
atoms = append(atoms, name)
|
|
|
|
}
|
|
|
|
utils.SortStrings(&atoms)
|
|
|
|
return atoms
|
|
|
|
}
|
|
|
|
|
|
|
|
func (fml FormulaConjunct) GetAtoms() []string {
|
|
|
|
return getAtomsFromArrayOfLiterals(fml)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (fml FormulaDisjunct) GetAtoms() []string {
|
|
|
|
return getAtomsFromArrayOfLiterals(fml)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (fml FormulaHornClause) GetAtoms() []string {
|
|
|
|
return getAtomsFromArrayOfArraysOfLiterals([][]Formula{fml.Pos, fml.Neg})
|
|
|
|
}
|
|
|
|
|
|
|
|
func (fml FormulaKNF) GetAtoms() []string {
|
|
|
|
var fmlArrays = make([][]Formula, len(fml))
|
|
|
|
for i, term := range fml {
|
|
|
|
fmlArrays[i] = term
|
|
|
|
}
|
|
|
|
return getAtomsFromArrayOfArraysOfLiterals(fmlArrays)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (fml FormulaDNF) GetAtoms() []string {
|
|
|
|
var fmlArrays = make([][]Formula, len(fml))
|
|
|
|
for i, term := range fml {
|
|
|
|
fmlArrays[i] = term
|
|
|
|
}
|
|
|
|
return getAtomsFromArrayOfArraysOfLiterals(fmlArrays)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (fml FormulaHorn) GetAtoms() []string {
|
|
|
|
var fmlArrays = make([][]Formula, 2*len(fml))
|
|
|
|
for i, hornclause := range fml {
|
|
|
|
fmlArrays[i] = append(hornclause.Neg, hornclause.Pos...)
|
|
|
|
}
|
|
|
|
return getAtomsFromArrayOfArraysOfLiterals(fmlArrays)
|
|
|
|
}
|