public ResultSentence <EValidationResult> Validate(IWorldPL1Structure pL1Structure, Dictionary <string, string> dictVariables)
{
ResultSentence <EValidationResult> result = ResultSentence <EValidationResult> .CreateResult(true, EValidationResult.True);
if (_type == EQuantumType.None)
{
result = ResultSentence <EValidationResult> .CreateResult(false, EValidationResult.UnexpectedResult, "Parser failed. Quantumtype not detected");
}
var arguments = GetArgumentsOfType <IFormulaValidate>().ToList();
if (arguments.Count != 1)
{
result = ResultSentence <EValidationResult> .CreateResult(false, EValidationResult.UnexpectedResult,
"Invalid amount of arguments in quantum : " + arguments.Count);
}
else
{
if (_type == EQuantumType.All)
{
result = ValidateAllQuantum(pL1Structure, dictVariables);
}
else if (_type == EQuantumType.Exist)
{
result = ValidateExistQuantum(pL1Structure, dictVariables);
}
}
return(result);
}
public ResultSentence <EValidationResult> Validate(IWorldPL1Structure pL1Structure, Dictionary <string, string> dictVariables)
{
ResultSentence <EValidationResult> result = ResultSentence <EValidationResult> .CreateResult(true, EValidationResult.False);
foreach (var conjunctionPart in GetArgumentsOfType <IFormulaValidate>())
{
ResultSentence <EValidationResult> validate = conjunctionPart.Validate(pL1Structure, dictVariables);
if (validate.IsValid)
{
if (validate.Value == EValidationResult.True)
{
result = ResultSentence <EValidationResult> .CreateResult(true, EValidationResult.True);
_validFormula = conjunctionPart as Formula;
}
else
{
_invalidFormula = conjunctionPart as Formula;
}
}
else
{
result = validate;
break;
}
}
return(result);
}
public override ResultSentence <string> GetPL1UniverseIdentifier(IWorldPL1Structure pL1WorldStructure, Dictionary <string, string> dictVariables)
{
PL1Structure pl1Structure = pL1WorldStructure.GetPl1Structure();
ConstDictionary constDict = pl1Structure.GetConsts();
FunctionDictionary funcDict = pl1Structure.GetFunctions();
ResultSentence <List <string> > universeIdentifier = GetUniverseIdentifier(Arguments, pL1WorldStructure, dictVariables);
ListDictionary listDict = funcDict.TryGetValue(Name);
if (pL1WorldStructure is IWorldSignature worldSignature)
{
Signature signature = worldSignature.GetSignature();
if (!signature.Functions.Any(elem => elem.Item1 == Name && elem.Item2 == Arguments.Count))
{
return(ResultSentence <string> .CreateResult(EValidationResult.UnknownSymbol, false, "", "Function " + Name + " not found in signature."));
}
}
if (!universeIdentifier.IsValid)
{
return(ResultSentence <string> .CreateResult(universeIdentifier.ValidationResult, false, universeIdentifier.Value.FirstOrDefault(), universeIdentifier.ErrorMessage));
}
string result = listDict.TryGetValue(universeIdentifier.Value);
return(ResultSentence <string> .CreateResult(true, result));
}
public ResultSentence <EValidationResult> Validate(IWorldPL1Structure pL1Structure, Dictionary <string, string> dictVariables)
{
if (_formula != null && _formula is IFormulaValidate formulaValidate)
{
return(formulaValidate.Validate(pL1Structure, dictVariables));
}
return(ResultSentence <EValidationResult> .CreateResult(false, EValidationResult.UnexpectedResult, "No Formula in Parenthese"));
}
public ResultSentence <EValidationResult> Validate(IWorldPL1Structure pL1Structure, Dictionary <string, string> dictVariables)
{
ResultSentence <EValidationResult> result = ResultSentence <EValidationResult> .CreateResult(true, EValidationResult.False);
ConstDictionary constDict = pL1Structure.GetPl1Structure().GetConsts();
PredicateDictionary predDict = pL1Structure.GetPl1Structure().GetPredicates();
if (pL1Structure is IWorldSignature worldSignature)
{
Signature signature = worldSignature.GetSignature();
var correctElement = signature.Predicates.Find(elem => elem.Item1 == Name);
if (string.IsNullOrEmpty(correctElement.Item1))
{
return(ResultSentence <EValidationResult> .CreateResult(false, EValidationResult.UnknownSymbol, "Predicate " + Name + $" not found in the signature."));
}
else if (correctElement.Item2 != Arguments.Count)
{
return(ResultSentence <EValidationResult> .CreateResult(false, EValidationResult.UnknownSymbol, "Predicate " + Name + $" has arity {correctElement.Item2}, but is applied to {Arguments.Count} arguments"));
}
}
ResultSentence <List <string> > universeArguments = Argument.GetUniverseIdentifier(Arguments, pL1Structure, dictVariables);
List <List <string> > predicateList = predDict.TryGetValue(Name);
if (!universeArguments.IsValid)
{
result = ResultSentence <EValidationResult> .CreateResult(false, universeArguments.ValidationResult, universeArguments.ErrorMessage);
}
else
{
foreach (var predElem in predicateList)
{
if (predElem.SequenceEqual(universeArguments.Value))
{
result = ResultSentence <EValidationResult> .CreateResult(true, EValidationResult.True);
break;
}
}
}
return(result);
}
public override ResultSentence <string> GetPL1UniverseIdentifier(IWorldPL1Structure pL1Structure, Dictionary <string, string> dictVariables)
{
if (pL1Structure.GetPl1Structure().GetConsts().ContainsKey(Name))
{
return(ResultSentence <string> .CreateResult(true, Name));
}
if (pL1Structure is IWorldSignature worldSignature)
{
if (worldSignature.GetSignature().Consts.Any(s => s == FormattedFormula))
{
return(ResultSentence <string> .CreateResult(EValidationResult.ConstantNotUsed, false, FormattedFormula, ErrorLogFields.VALIDATION_CONSTANTNOTINWORLD + $"[{FormattedFormula}]"));
}
else
{
return(ResultSentence <string> .CreateResult(EValidationResult.UnknownSymbol, false, FormattedFormula, ErrorLogFields.VALIDATION_ARGUMENTUNKNOWN + $"[{FormattedFormula}]"));
}
}
return(ResultSentence <string> .CreateResult(EValidationResult.UnexpectedResult, false, FormattedFormula, "Could not find the signature: \n" + Environment.StackTrace));
}
public string GetWorldConstant(IWorldPL1Structure pL1WorldStructure, Dictionary <string, string> dictVariables)
{
PL1Structure pl1Structure = pL1WorldStructure.GetPl1Structure();
ConstDictionary constDict = pl1Structure.GetConsts();
FunctionDictionary funcDict = pl1Structure.GetFunctions();
Result <List <string> > universeIdentifier = GetUniverseIdentifier(Arguments, pL1WorldStructure, dictVariables);
ListDictionary listDict = funcDict.TryGetValue(Name);
string result = listDict.TryGetValue(universeIdentifier.Value);
foreach (KeyValuePair <string, string> valuePair in constDict)
{
if (result == valuePair.Value)
{
return(valuePair.Key);
}
}
return("WorldConstant not found");
}
public ResultSentence <EValidationResult> Validate(IWorldPL1Structure pL1Structure, Dictionary <string, string> dictVariables)
{
ResultSentence <EValidationResult> result = ResultSentence <EValidationResult> .CreateResult(true, EValidationResult.False);
var arguments = GetArgumentsOfType <IFormulaValidate>().ToList();
if (arguments.Count != 2)
{
result = ResultSentence <EValidationResult> .CreateResult(false, EValidationResult.UnexpectedResult,
"Implication has invalid amount of arguments " + arguments.Count);
}
else
{
var result1 = arguments[0].Validate(pL1Structure, dictVariables);
var result2 = arguments[1].Validate(pL1Structure, dictVariables);
if (result1.IsValid && result2.IsValid)
{
if (result1.Value == EValidationResult.False || result2.Value == EValidationResult.True)
{
result = ResultSentence <EValidationResult> .CreateResult(EValidationResult.True);
}
else
{
result = ResultSentence <EValidationResult> .CreateResult(EValidationResult.False);
}
}
else
{
if (!result1.IsValid)
{
result = result1;
}
else
{
result = result2;
}
}
}
return(result);
}
public override ResultSentence <string> GetPL1UniverseIdentifier(IWorldPL1Structure pL1Structure, Dictionary <string, string> dictVariables)
{
if (dictVariables.ContainsKey(FormattedFormula))
{
return(ResultSentence <string> .CreateResult(true, dictVariables[FormattedFormula]));
}
if (pL1Structure is IWorldSignature worldSignature)
{
if (worldSignature.GetSignature().Variables.Any(s => s == FormattedFormula))
{
return(ResultSentence <string> .CreateResult(EValidationResult.ContainsFreeVariable, false, FormattedFormula, ErrorLogFields.VALIDATION_FREEVARIABLES + $"[{FormattedFormula}]"));
}
else
{
return(ResultSentence <string> .CreateResult(EValidationResult.UnknownSymbol, false, FormattedFormula, ErrorLogFields.VALIDATION_ARGUMENTUNKNOWN + $"[{FormattedFormula}]"));
}
}
return(ResultSentence <string> .CreateResult(EValidationResult.UnexpectedResult, false, FormattedFormula, "Could not find the signature: \n" + Environment.StackTrace));
}
public ResultSentence <EValidationResult> Validate(IWorldPL1Structure pL1Structure, Dictionary <string, string> dictVariables)
{
ResultSentence <List <string> > universeIdentifier = Argument.GetUniverseIdentifier(Arguments, pL1Structure, dictVariables);
if (!universeIdentifier.IsValid)
{
return(ResultSentence <EValidationResult> .CreateResult(false, EValidationResult.ConstantNotUsed, universeIdentifier.ErrorMessage));
}
string u1 = universeIdentifier.Value[0];
string u2 = universeIdentifier.Value[1];
if (u1 == u2)
{
return(ResultSentence <EValidationResult> .CreateResult(true, EValidationResult.True));
}
else
{
return(ResultSentence <EValidationResult> .CreateResult(true, EValidationResult.False));
}
}
private ResultSentence <EValidationResult> ValidateExistQuantum(IWorldPL1Structure pL1Structure, Dictionary <string, string> dictVariables)
{
var arguments = GetArgumentsOfType <IFormulaValidate>().First();
var result = ResultSentence <EValidationResult> .CreateResult(true, EValidationResult.False);
foreach (var identifier in pL1Structure.GetPl1Structure().GetConsts())
{
var dict = new Dictionary <string, string>(dictVariables);
if (!dict.ContainsKey(_variable.FormattedFormula))
{
dict.Add(_variable.FormattedFormula, identifier.Key);
}
else
{
dict[_variable.FormattedFormula] = identifier.Key;
}
var helpResult = arguments.Validate(pL1Structure, dict);
if (!helpResult.IsValid)
{
result = helpResult;
break;
}
if (helpResult.Value == EValidationResult.True)
{
result = helpResult;
_validConstPair = new KeyValuePair <string, string>(_variable.Name, identifier.Key);
break;
}
else
{
_invalidConstPair = new KeyValuePair <string, string>(_variable.Name, identifier.Key);
}
}
return(result);
}
public ResultSentence <EValidationResult> Validate(IWorldPL1Structure pL1Structure, Dictionary <string, string> dictVariables)
{
if (_formula != null && _formula is IFormulaValidate formulaValidate)
{
var res = formulaValidate.Validate(pL1Structure, dictVariables);
if (res.IsValid)
{
if (res.Value == EValidationResult.True)
{
return(ResultSentence <EValidationResult> .CreateResult(true, EValidationResult.False));
}
else
{
return(ResultSentence <EValidationResult> .CreateResult(true, EValidationResult.True));
}
}
else
{
return(res);
}
}
return(ResultSentence <EValidationResult> .CreateResult(false, EValidationResult.UnexpectedResult, "No Formula in Negation"));
}
public static ResultSentence <List <string> > GetUniverseIdentifier(List <Argument> arguments, IWorldPL1Structure pL1WorldStructure, Dictionary <string, string> dictVariables)
{
ResultSentence <List <string> > universeArguments = ResultSentence <List <string> > .CreateResult(true, new List <string>());
ConstDictionary constDict = pL1WorldStructure.GetPl1Structure().GetConsts();
foreach (var item in arguments)
{
ResultSentence <string> universeIdentifier = item.GetPL1UniverseIdentifier(pL1WorldStructure, dictVariables);
if (universeIdentifier.IsValid)
{
universeArguments.Value.Add(constDict.TryGetValue(universeIdentifier.Value));
}
else
{
universeArguments = ResultSentence <List <string> > .CreateResult(universeIdentifier.ValidationResult, false, new List <string>() { universeIdentifier.Value }, universeIdentifier.ErrorMessage);
break;
};
}
return(universeArguments);
}
public abstract ResultSentence <string> GetPL1UniverseIdentifier(IWorldPL1Structure pL1Structure, Dictionary <string, string> dictVariables);
