public ConstrainActions
(ConclusionClass _conclusionClass, ViewModel _viewModel, GatheredBases _bases)
{
_conclusionClass = conclusionClass;
viewModel = _viewModel;
bases = _bases;
}
public static int CheckRedundancyWithRules
(List <List <SimpleTree> > possibleTrees, GatheredBases bases)
{
int i = 0;
foreach (var firstSimpleTree in possibleTrees)
{
foreach (var secoundSimpleTree in possibleTrees)
{
if (firstSimpleTree != secoundSimpleTree)
{
var firstList = firstSimpleTree.Where(p => p.Askable).ToList();
var secoundList = secoundSimpleTree.Where(p => p.Askable).ToList();
bool value = CompareRules(firstList, secoundList);
CompareRulesForConstrainRedundancy(firstList, secoundList, bases);
if (value == false)
{
i++;
ReportRedundancyInRules(firstSimpleTree, secoundSimpleTree);
goto lab;
}
}
}
}
lab:
if (i == 0)
{
return(1);
}
return(2);
}
private void method()
{
bases = new GatheredBases();
Rule r = new Rule(1, "Dziadek", new List <string>()
{
"Ojciec"
}, true);
Rule r1 = new Rule(2, "Dziadek", new List <string>()
{
"Ciocia"
}, true);
Rule r2 = new Rule(3, "Ciocia", new List <string>()
{
"Corka"
}, true);
Rule r22 = new Rule(5, "Ciocia", new List <string>()
{
"Syn"
}, true);
Rule r3 = new Rule(4, "Syn", new List <string>()
{
"Julek"
}, true);
rules.RulesList.Add(r);
rules.RulesList.Add(r1);
rules.RulesList.Add(r2);
rules.RulesList.Add(r3);
rules.RulesList.Add(r22);
bases.RuleBase = rules;
}
public static bool MethodForContradiction
(GatheredBases bases, Rule ruleForCheck, int count, List <List <Rule> > differenceList, out SimpleTree tree)
{
tree = new SimpleTree {
rule = ruleForCheck
};
IEnumerable <SimpleTree> parentWithoutChildren;
int _number = 0;
do
{
parentWithoutChildren = TreeOperations.TreeToEnumerable(tree).Where(p => p.Children.Count == 0).
Where(p => p.Askable == false);
foreach (SimpleTree parentWithoutChild in parentWithoutChildren)
{
TreeOperations.ExpandBrunchOrMakeAskable(bases, parentWithoutChild, differenceList);
_number++;
if (_number == count)
{
return(false); // method not finished tree after _number iterations
} //TODO: ta pętla nie jest odporna na sprzeczność
}
} while (parentWithoutChildren.Count() != 0);
return(true); // method finished tree and there is no contradiction
}
public static void CheckContradictionWIthModelsAndRulebase(GatheredBases bases)
{
foreach (Rule rule in bases.RuleBase.RulesList)
{
List <List <Rule> > differenceList;
var tree = TreeOperations.ReturnComplexTreeAndDifferences(bases, rule, out differenceList);
var askingConditions = TreeOperations.TreeToEnumerable
(tree).Where(p => p.Askable);
foreach (SimpleTree condition in askingConditions)
{
IEnumerable <Model> models =
bases.ModelsBase.ModelList.Where(p => p.Conclusion == condition.rule.Conclusion);
if (models.Count() != 0)
{
// trzeba zebrać wszystkie warunki startowe
// jeszcze zrobić mały research
foreach (Model model in models)
{
var list = new List <string>();
List <string> listOfStartedConditions = GatherStartConditions
(model, bases, list);
//TODO:METODA sprzeczności w modelach
// z modelami relacyjnymi oraz modeli arytmetycznych z modelami arytmetycznymi
CheckContradictionBetweenRulesAndStartedConditions
(listOfStartedConditions, condition, model);
// CheckContradictionBetweenModelsAndStartedConditions();
// CheckContradictionBetweenArithmeticModels();
}
}
}
}
}
public void Sprawdzamy_Wnioskowania()
{
GatheredBases bases = new GatheredBases();
RuleBase rules = new RuleBase();
Rule r = new Rule(1, "Wniosek", new List <string>()
{
"Wniosek1"
}, true);
Rule r1 = new Rule(2, "Wniosek1", new List <string>()
{
"Wniosek2"
}, true);
Rule r2 = new Rule(3, "Wniosek2", new List <string>()
{
"Wniosek3"
}, true);
Rule r22 = new Rule(5, "Wniosek2", new List <string>()
{
"Wniosek6"
}, true);
Rule r3 = new Rule(4, "Wniose3", new List <string>()
{
"Wniosek4"
}, true);
rules.RulesList.Add(r);
rules.RulesList.Add(r1);
rules.RulesList.Add(r2);
rules.RulesList.Add(r3);
rules.RulesList.Add(r22);
bases.RuleBase = rules;
TreeOperations.ReturnComplexTreeAndDifferences(bases, r);
Assert.AreEqual(true, true);
}
public ModelActions
(ConclusionClass _conclusionClass, ViewModel _viewModel, GatheredBases _bases, IElementsNamesLanguageConfig config)
{
conclusionClass = _conclusionClass;
viewModel = _viewModel;
bases = _bases;
_config = config;
}
/// <summary>
/// Initializes a new instance of the <see cref="ConclusionClass"/> class.
/// </summary>
/// <param name="bases">The bases.</param>
/// <param name="viewModel">The view model.</param>
public ConclusionClass(GatheredBases bases, ViewModel viewModel, IElementsNamesLanguageConfig config)
{
_bases = bases;
_viewModel = viewModel;
_config = config;
_constrainActions = new ConstrainActions(this, _viewModel, bases);
_modelActions = new ModelActions(this, _viewModel, bases, config);
}
public ActionsOnBase(GatheredBases bases, ViewModel model, IElementsNamesLanguageConfig config)
{
_viewModel = model;
_config = config;
_bases = bases;
conclusion = new ConclusionClass(_bases, _viewModel, config);
_constrainActions = new ConstrainActions(conclusion, _viewModel, _bases);
}
private static Constrain CompareRulesForConstrainRedundancy
(List <SimpleTree> firstList, List <SimpleTree> secoundList, GatheredBases bases)
{
//Function check if firstList is a part of secoundList
int count = 0;
var returnedConstrain = new Constrain();
if (firstList.Count == secoundList.Count)
{
var newFirstList = firstList.OrderBy(p => p.rule.Conclusion);
var newSecoundList = secoundList.OrderBy(tree => tree.rule.Conclusion);
var secoundListAdd = newSecoundList.ToList();
var firstListAdd = newFirstList.ToList();
var firstElement = new SimpleTree();
var secoundElement = new SimpleTree();
for (int i = 0; i < firstList.Count; i++)
{
if (secoundListAdd[i].rule.Conclusion != firstListAdd[i].rule.Conclusion)
{
firstElement = firstListAdd[i];
secoundElement = secoundListAdd[i];
count++;
}
}
if (count == 1)
{
foreach (var constrain in bases.ConstrainBase.ConstrainList)
{
int licz = 0;
foreach (var condition in constrain.ConstrainConditions)
{
if (firstElement.rule.Conclusion == condition)
{
licz++;
}
if (secoundElement.rule.Conclusion == condition)
{
licz++;
}
}
if (licz == 2)
{
returnedConstrain = constrain;
}
}
return(returnedConstrain);
}
}
return(returnedConstrain);
}
public ForwardChaining(GatheredBases bases, ConclusionClass conclusion, ViewModel viewModel,
ConstrainActions constrainActions)
{
_bases = bases;
_conclusion = conclusion;
_viewModel = viewModel;
_constrainActions = constrainActions;
_modelActions = new ModelActions(_conclusion, _viewModel, bases, viewModel._elementsNamesLanguageConfig);
}
public static List <Rule> CheckOutsideContradiction(GatheredBases bases, bool reportIncluded)
{
var contradictedRules = new List <Rule>();
foreach (Rule RuleI in bases.RuleBase.RulesList)
{
var differenceList = new List <List <Rule> >();
int numberForCheck = 100;
do
{
var tree = new SimpleTree();
var complexTreeValue = MethodForContradiction(bases, RuleI, numberForCheck, differenceList, out tree);
if (complexTreeValue == false)
{
IEnumerable <SimpleTree> currentEndOfTree =
TreeOperations.TreeToEnumerable(tree).Where(p => p.Children.Count == 0);
foreach (SimpleTree currentEnd in currentEndOfTree)
{
SimpleTree node = currentEnd;
SimpleTree checkedValue = currentEnd;
while (node.Parent != null)
{
node.rule = node.Parent.rule;
if (checkedValue == node)
{
if (reportIncluded)
{
MessageBox.Show(
"W bazie występuje sprzeczność przejdź do dniagnoz bazy aby poznać szczegóły");
reportIncluded = false; //TODO : tymczasowe rozwiązanie trzeba jakoś przerwać metodę
}
AddRuleToContradictionTable(contradictedRules, RuleI);
break;
}
}
}
numberForCheck = numberForCheck * 2;
// in case that there is no contradiction but
// also tree is not finished number is double
}
else
{
break;
}
} while (contradictedRules.Count == 0);
}
return(contradictedRules);
}
public static void ReportAboutContradictionInRules(GatheredBases bases, ViewModel _viewModel)
{
int i = 0;
List <Rule> listWithContradiction = CheckOutsideContradiction(bases, false);
foreach (Rule rule in listWithContradiction)
{
i += CheckSelfContradiction(rule);
for (int count = 1; count < 1000; count++) //TODO:nie powinno być stałej w pętli for
{
var tree = new SimpleTree();
var differenceList = new List <List <Rule> >();
MethodForContradiction(bases, rule, count, differenceList, out tree);
IEnumerable <SimpleTree> ListOfTreesElements =
TreeOperations.TreeToEnumerable(tree).Where(p => p.Children.Count == 0);
foreach (SimpleTree treeElement in ListOfTreesElements)
{
string s = "";
SimpleTree copyOfTree = treeElement;
if (treeElement.rule.NumberOfRule == rule.NumberOfRule)
{
i++;
bool boolValue = true;
while (copyOfTree.Parent.rule != rule)
{
if (boolValue == false)
{
copyOfTree = copyOfTree.Parent;
}
boolValue = false;
s += copyOfTree.rule.NumberOfRule + "==>";
}
//TODO: Report aboyt contradiction
MessageBox.Show("Poprzez podstawienie następujących reguł otrzymasz sprzeczność zewnetrzną :" + s + "\n");
_viewModel.ButtonsLogic.ConclusionEnabled = false;
goto Res;
}
}
}
Res :;
}
if (i == 0)
{
MessageBox.Show("Nie wykryto sprzeczności w bazie reguł");
_viewModel.ButtonsLogic.ConclusionEnabled = true;
}
}
public ViewModel()
{
#region LanguageConfiguration
MainWindowLanguageConfig = new PolishMainWindowLanguageConfig();
ChildWindowsLanguageConfig = new PolishChildWindowsLanguageConfig();
_elementsNamesLanguageConfig = new PolishElementsNamesLanguageConfig();
PolishConfigurationCommand = new RelayCommand(p =>
{
MainWindowLanguageConfig = new PolishMainWindowLanguageConfig();
ChildWindowsLanguageConfig = new PolishChildWindowsLanguageConfig();
_elementsNamesLanguageConfig = new PolishElementsNamesLanguageConfig();
});
EnglishConfigurationCommand = new RelayCommand(p =>
{
MainWindowLanguageConfig = new EnglishMainWindowLanguageConfig();
ChildWindowsLanguageConfig = new EnglishChildWindowsLanguageConfig();
_elementsNamesLanguageConfig = new EnglishElementsLanguageConfig();
});
_basesCommands = new BasesCommands(this);
_buttonsLogic = new ButtonsLogic(this);
#endregion
bases = new GatheredBases(this);
//Instances of classes responsible for opening and actions on RMSE bases
_openBasesActions = new OpenBasesActions(this, bases);
_actionsOnBase = new ActionsOnBase(bases, this, _elementsNamesLanguageConfig);
#region ConclusionButtons
ConcludeCommand = new RelayCommand(pars => _actionsOnBase.BackwardConcludeAction(_selectedRule));
OpenBackwardConcludeWindowCommand = new RelayCommand(p => ShowWindow(new ChooseRule(this)));
ForwardConcludeCommand = new RelayCommand(p => _actionsOnBase.ForwardConcludeAction());
#endregion
ValueTrue = new RelayCommand(p => CheckedRuleVal = true);
ValueUnknown = new RelayCommand(p => CheckedRuleVal = false);
StartConditionValueTrue = new RelayCommand(p => StartConditionValue = true);
StartConditionValueUnknown = new RelayCommand(p => StartConditionValue = false);
BreakButtonCommand = new RelayCommand(p => ExceptionValue = true);
ClearConsoleCommand = new RelayCommand(p => MainWindowText1 = "");
ArgumentNullCommand = new RelayCommand(p => ArgumentNullMethod());
}
public static void GeneralCheckRedundancyMethod(GatheredBases bases, RedundancyMethod typeOfRedundancy)
{
var alreadyChecked = new List <string>();
bool withRules = false;
bool withConstrains = false;
bool typeRules = false;
// program checks all rule with same conclusion. That table exist to avoid double checking
foreach (Rule ruleForCheck in bases.RuleBase.RulesList)
{
if (alreadyChecked.Contains(ruleForCheck.Conclusion) == false)
{
var allFlatteredRules = AllFlatteredRules(bases, ruleForCheck);
var i = typeOfRedundancy(allFlatteredRules, bases);
// delegate CheckRedundancyWithRules or another method
alreadyChecked.Add(ruleForCheck.Conclusion);
if (1 == i || 2 == i)
{
typeRules = true;
}
if (i == 2)
{
withRules = true;
}
if (i == 32)
{
withConstrains = true;
}
}
}
if (typeRules)
{
if (withRules == false)
{
MessageBox.Show("Nie wykryto nadmiarowości w bazie reguł");
}
}
if (typeRules == false)
{
if (withConstrains == false)
{
MessageBox.Show("Nie wykryto nadmiarowości lącznych w bazie reguł i ograniczeń");
}
}
}
public static int CheckRedundancyWithConstrain(List <List <SimpleTree> > possibleTrees,
GatheredBases bases)
{
int i = 0;
List <List <SimpleTree>[]> checkedList = new List <List <SimpleTree>[]>();
foreach (var first in possibleTrees)
{
foreach (var secound in possibleTrees)
{
List <SimpleTree>[] list = new List <SimpleTree>[2] {
first, secound
};
var groupedList = list.GroupBy(p => p.First().rule.Conclusion).ToList();
foreach (IGrouping <string, List <SimpleTree> > grouping in groupedList)
{
}
list = new List <SimpleTree> [2];
{
if (first != secound)
{
List <SimpleTree> firstList = first.Where(p => p.Askable).ToList();
List <SimpleTree> secoundList = secound.Where(p => p.Askable).ToList();
var value = CompareRulesForConstrainRedundancy(firstList, secoundList, bases);
if (value.ConstrainConditions.Count != 0)
{
ReportRedundancyInConstrains(first, secound, value);
i++;
goto lab;
}
}
}
}
}
lab:
;
if (i == 0)
{
return(21);
}
return(32);
}
public static List <List <SimpleTree> > AllFlatteredRules(GatheredBases bases, Rule ruleForCheck)
{
List <List <SimpleTree> > allFlatteredRules = new List <List <SimpleTree> >();
List <Rule> ruleList = ConclusionClass.FindRulesWithParticularConclusion
(ruleForCheck.Conclusion, bases.RuleBase.RulesList);
foreach (var r in ruleList)
{
List <List <Rule> > differencesList;
var tree = TreeOperations.ReturnComplexTreeAndDifferences(
bases, r, out differencesList);
List <List <SimpleTree> > possibleTrees = TreeOperations.ReturnPossibleTrees(tree,
differencesList);
allFlatteredRules.AddRange(possibleTrees);
}
return(allFlatteredRules);
}
public static void CheckContradictionWithConstarinsMethod(GatheredBases bases)
{
int contradictionNumber = 0;
var alreadyChecked = new List <string>();
foreach (Rule ruleForCheck in bases.RuleBase.RulesList)
{
if (alreadyChecked.Contains(ruleForCheck.Conclusion) == false)
{
var allFlatteredRules = Redundancy.AllFlatteredRules(bases, ruleForCheck);
contradictionNumber += Contradiction.CheckContradictionWithConstrains(allFlatteredRules, bases);
alreadyChecked.Add(ruleForCheck.Conclusion);
}
}
if (contradictionNumber == 0)
{
MessageBox.Show("Nie wykryto sprzeczności łącznych pomiędzy bazą reguł a bazą ograniczeń");
}
}
private static List <string> GatherStartConditions(Model model, GatheredBases bases, List <string> r)
{
if (model.StartCondition != "bez warunku")
{
r.Add(model.StartCondition);
}
if (model.ModelType == "simple")
{
IEnumerable <Model> models = bases.ModelsBase.ModelList.Where(p => p.Conclusion == model.FirstArg);
foreach (Model model1 in models)
{
r.AddRange(GatherStartConditions(model1, bases, r)); //
}
models = bases.ModelsBase.ModelList.Where(p => p.Conclusion == model.SecoundArg);
foreach (Model model1 in models)
{
r.AddRange(GatherStartConditions(model1, bases, r)); //
}
}
else if (model.ModelType == "extended")
{
foreach (string argument in model.ArgumentsList)
{
string argument1 = argument;
IEnumerable <Model> models = bases.ModelsBase.ModelList.Where(p => p.Conclusion == argument1);
foreach (Model model1 in models)
{
r.AddRange(GatherStartConditions(model1, bases, r)); //
}
}
}
else
{
r.Add(model.StartCondition);
}
return(r);
}
public static void ExpandBrunchOrMakeAskable
(GatheredBases bases, SimpleTree parentWithoutChild, List <List <Rule> > divideList)
{
foreach (string condition in parentWithoutChild.rule.Conditions)
{
List <Rule> returnedRules = ConclusionClass.FindRulesWithParticularConclusion(condition,
bases.RuleBase.RulesList);
if (returnedRules.Count == 0)
{
bool isModel = CheckIfModel(condition, bases);
var endRule = new Rule
{
Conclusion = condition,
NumberOfRule = bases.RuleBase.RulesList.Count + 1000
};
parentWithoutChild.Children.Add(new SimpleTree
{
Model = isModel,
Askable = true,
rule = endRule,
Parent = parentWithoutChild //todo:nie wiem czy nie lepiej bêdzie jak dopyt i model bêd¹ w endRule
});
}
else
{
List <SimpleTree> alternativeBranches = ReturnAlternativeBranches(returnedRules, parentWithoutChild);
//
parentWithoutChild.Children.AddRange(alternativeBranches);
if (returnedRules.Count > 1)
{
divideList.Add(returnedRules);
}
}
}
}
public static SimpleTree ReturnComplexTreeAndDifferences
(GatheredBases bases, Rule ruleForCheck, out List <List <Rule> > differencesList)
{
differencesList = new List <List <Rule> >();
var conditionTree = new SimpleTree {
rule = ruleForCheck
};
IEnumerable <SimpleTree> parentWithoutChildren;
do
{
parentWithoutChildren = TreeToEnumerable(conditionTree).Where(p => p.Children.Count == 0).
Where(p => p.Askable == false);
foreach (SimpleTree parentWithoutChild in parentWithoutChildren)
{
ExpandBrunchOrMakeAskable(bases, parentWithoutChild, differencesList);
}
} while (parentWithoutChildren.Count() != 0);
return(conditionTree);
}
private void FillBase(GatheredBases _bases)
{
//var a =new Rule();
//var b = new Rule();
//var c =new Rule();
//var d =new Rule();
//a.Conclusion = "a";
//b.Conclusion = "b";
//c.Conclusion = "c";
//d.Conclusion = "d";
//a.Conditions= new List<string>(){"b"};
//a.Conditions = new List<string>() { "c" };
//c.Conditions = new List<string>() { "d" };
//bases.RuleBase.RulesList.Add(a);
//bases.RuleBase.RulesList.Add(b);
//bases.RuleBase.RulesList.Add(c);
//bases.RuleBase.RulesList.Add(d);
bases.RuleBase.ReadRules("REstudent.BED");
//Constrain cons = new Constrain(new List<string>(){"d","e"},1 );
//bases.ConstrainBase.ConstrainList.Add(cons);
}
public static int CheckContradictionWithConstrains
(List <List <SimpleTree> > allFlatteredRules, GatheredBases bases)
{
int contradictionNumber = 0;
// todo : tutaj też warto posortowac listy zeby uniknac błędu
foreach (var constrain in bases.ConstrainBase.ConstrainList)
{
foreach (var ruleFlattered in allFlatteredRules)
{
List <SimpleTree> askable = ruleFlattered.Where(p => p.Askable).ToList();
int i = 0;
foreach (var simpleTree in askable)
{
foreach (var condition in constrain.ConstrainConditions)
//TODO:tutaj jest rozwiązanie na sprzeczność jeżeli w jednym spłaszczeniu są dwie reguły sprzeczna
{
if (simpleTree.rule.Conclusion == condition)
{
i++;
}
}
}
if (i > 1)
{
contradictionNumber++;
IEnumerable <SimpleTree> firstParent = ruleFlattered.Where(p => p.Parent == null);
MessageBox.Show("Jest sprzeczność z bazą ograniczeń pomiędzy regułą " +
firstParent.First().rule.Conclusion + " a"
+ "ograniczeniem nr" + constrain.NumberOfConstrain);
}
}
}
return(contradictionNumber);
}
public OpenBasesActions(ViewModel viewModel, GatheredBases bases)
{
_viewModel = viewModel;
_gatheredBases = bases;
}
public static bool CheckIfModel(string condition, GatheredBases bases)
{
return(bases.ModelsBase.ModelList.Any(model => model.Conclusion == condition));
}
