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)); }