public static JsonModel CreateFromBaseOpeator(IAsciiBasePropositionalOperator baseOperator)
{
var json = new JsonModel();
var text = new TextModel();
text.title = baseOperator.ToName();
json.text = text;
if (baseOperator.GetChilds() != null)
{
json.children = baseOperator.GetChilds().Where(x => x != null).Select(CreateFromBaseOpeator).ToList();
}
return(json);
}
private int NotCalcScore(IAsciiBasePropositionalOperator baseOperator)
{
switch (baseOperator)
{
case AndPropositionalOperator _:
return(3);
case NotPropositionalOperator _:
return(CalcScore(baseOperator.GetChilds()[0]));
case OrPropositionalOperator _:
return(1);
case ExtensionalQuantifierOperator _:
return(5);
case UniversalQuantifierOperator _:
return(4);
case AbstractConstantPropositionalOperator _:
return(6);
}
throw new NotImplementedException();
}
private void AddChild(IAsciiBasePropositionalOperator baseOperator)
{
//Console.WriteLine("Child: "+ baseOperator.ToLogicString());
IAsciiBasePropositionalOperator work;
if (baseOperator is NotPropositionalOperator)
{
var temp = baseOperator.GetChilds()[0].Negate();
work = temp;
}
else
{
work = baseOperator;
}
var stop = operatorsMadeIntoChilds.Contains(work) || operatorsMadeIntoChilds.Contains(baseOperator);
operatorsMadeIntoChilds.Add(baseOperator);
if (stop)
{
Console.WriteLine("STOP!");
return;
}
operatorsMadeIntoChilds.Add(work);
if (work is OrPropositionalOperator)
{
AddOrChild(baseOperator, work.GetChilds()[0]);
if (!work.GetChilds()[0].Equals(work.GetChilds()[1]))
{
AddOrChild(baseOperator, work.GetChilds()[1]);
}
return;
}
if (work is AndPropositionalOperator)
{
List <IAsciiBasePropositionalOperator> list = operators.Where(x => x != baseOperator).ToList();
var first = work.GetChilds()[0];
var second = work.GetChilds()[1];
if (!list.Contains(first))
{
list.Add(first);
}
if (!list.Contains(second))
{
list.Add(second);
}
var child = new TableuaxStep(list, ExtensionalVariables);
childs.Add(child);
return;
}
if (work is AbstractConstantPropositionalOperator)
{
List <IAsciiBasePropositionalOperator> list = operators.Where(x => x != baseOperator).ToList();
if (!list.Contains(work))
{
list.Add(work);
}
var child = new TableuaxStep(list, ExtensionalVariables);
childs.Add(child);
return;
}
if (work is AbstractQuantifierOperator)
{
HandleQuantifierOperators();
return;
}
throw new NotImplementedException();
}
private IAsciiBasePropositionalOperator Process(IAsciiBasePropositionalOperator work)
{
var logic = work as IAsciiSinglePropositionalOperator;
if (logic != null)
{
switch (logic.GetAsciiSymbol())
{
case '>':
var or = new OrPropositionalOperator(_manager);
or.Instantiate(new [] { SurroundWithNot(logic.GetChilds()[0]), logic.GetChilds()[1] });
return(HandleOr(or));
case '=':
var implication1 = new IfThenPropositionalOperator(_manager);
implication1.Instantiate(new [] { logic.GetChilds()[0], logic.GetChilds()[1] });
var implication2 = new IfThenPropositionalOperator(_manager);
implication2.Instantiate(new IAsciiBasePropositionalOperator[] { logic.GetChilds()[1], logic.GetChilds()[0] });
var and = new AndPropositionalOperator(_manager);
and.Instantiate(new IAsciiBasePropositionalOperator[] { implication1, implication2 });
return(HandleAnd(and));
case '&':
return(HandleAnd((AndPropositionalOperator)logic));
case '|':
return(HandleOr((OrPropositionalOperator)logic));
case '~':
return(logic);
case '%':
var nAnd = new AndPropositionalOperator(_manager);
nAnd.Instantiate(logic.GetChilds());
return(SurroundWithNot(HandleAnd(nAnd)));
case 'F':
return(new TruePropositionalOperator(_manager));
case 'T':
return(new FalsePropositionalOperator(_manager));
case '@':
if (work is UniversalQuantifierOperator workUnversal)
{
var ext = new ExtensionalQuantifierOperator(_manager);
ext.SetVariable(workUnversal.GetVariable());
ext.Instantiate(new[] { SurroundWithNot(logic.GetChilds()[0]) });
return(SurroundWithNot(ext));
}
break;
case '!':
if (work is ExtensionalQuantifierOperator workExtensional)
{
var universal = new UniversalQuantifierOperator(_manager);
universal.SetVariable(workExtensional.GetVariable());
universal.Instantiate(new[] { SurroundWithNot(logic.GetChilds()[0]) });
return(SurroundWithNot(universal));
}
break;
}
}
if (work is PredicateOperator predicate)
{
var result = new PredicateOperator(_manager);
result.SetName(predicate.GetName());
foreach (var child in work.GetChilds())
{
result.AddChild(Process(child));
}
return(result);
}
if (work is ScalarPropositionalOperator scalar)
{
return(_manager.RequestOperator(scalar.GetName()));
}
throw new System.Exception("Operator not found");
}