public static LogicDerivation ManipulateLogic(String paramString, LogicExpression paramLogicExpression)
{
var localLogicDerivation = new LogicDerivation(paramString, paramLogicExpression);
if (localLogicDerivation.CNFAndDNF)
{
return localLogicDerivation;
}
CarryOutNonPrimaryOperatorReplacement(localLogicDerivation);
CarryOutBoolValues(localLogicDerivation);
if (localLogicDerivation.CNFAndDNF)
{
return localLogicDerivation;
}
CarryOutAssociativity(localLogicDerivation);
CarryOutDeMorgans(localLogicDerivation);
CarryOutAssociativity(localLogicDerivation);
CarryOutIdempotency(localLogicDerivation);
CarryOutBoolValues(localLogicDerivation);
CarryOutAbsorbtion(localLogicDerivation);
do
{
CarryOutDistributivity(localLogicDerivation);
CarryOutAssociativity(localLogicDerivation);
CarryOutIdempotency(localLogicDerivation);
CarryOutBoolValues(localLogicDerivation);
CarryOutAbsorbtion(localLogicDerivation);
} while (!localLogicDerivation.CNFAndDNF);
return localLogicDerivation;
}
public ParsedExpression(String paramString, LogicExpression paramLogicExpression, LogicSyntax paramInt1, NegationSyntax paramInt2)
{
InitialText = paramString;
Expression = paramLogicExpression;
LogicSyntax = paramInt1;
NegationSyntax = paramInt2;
}
public LogicDerivation(String paramString, LogicExpression paramLogicExpression)
{
_initialText = paramString;
_steps = new List<LogicStep>();
AddStep(paramLogicExpression, "Initial parsed expression");
}
public override LogicExpression CloneLogic()
{
var localLogicBranch = new LogicBranch(Operator, Negated);
var arrayOfLogicExpression = new LogicExpression[_logicBranches.Length];
for (int i = 0; i < _logicBranches.Length; i++)
{
arrayOfLogicExpression[i] = _logicBranches[i].CloneLogic();
}
localLogicBranch.Branches = arrayOfLogicExpression;
return localLogicBranch;
}
public void AddStep(LogicExpression paramLogicExpression, String paramString)
{
var i = paramLogicExpression.GetLogicalForm();
Next = paramLogicExpression.CloneLogic();
var localLogicStep = new LogicStep
{
Expression = paramLogicExpression,
Comment = paramString,
Form = i
};
_steps.Add(localLogicStep);
int j = paramLogicExpression.GetNumberOfElements();
switch (i)
{
case Form.CNF:
if ((CNF == null) || (j < _cnfNumberOfElements))
{
CNF = paramLogicExpression;
_cnfNumberOfElements = j;
}
break;
case Form.DNF:
if ((DNF == null) || (j < _dnfNumberOfElements))
{
DNF = paramLogicExpression;
_dnfNumberOfElements = j;
}
break;
case Form.CNF_DNF:
if ((CNF == null) || (j < _cnfNumberOfElements))
{
CNF = paramLogicExpression;
_cnfNumberOfElements = j;
}
if ((DNF == null) || (j < _dnfNumberOfElements))
{
DNF = paramLogicExpression;
_dnfNumberOfElements = j;
}
break;
}
}
private static int IsAbsorbtion(LogicExpression left, LogicExpression right)
{
LogicExpression[] leftArray = left is LogicBranch ? ((LogicBranch) left).Branches : new[] {left};
LogicExpression[] rightArray = right is LogicBranch ? ((LogicBranch) right).Branches : new[] {right};
int i = leftArray.Length < rightArray.Length ? 1 : 0;
LogicExpression[] minArray;
LogicExpression[] maxArray;
if (leftArray.Length < rightArray.Length)
{
minArray = leftArray;
maxArray = rightArray;
}
else
{
minArray = rightArray;
maxArray = leftArray;
}
if (minArray.Any(t1 => !maxArray.Any(t1.Equals)))
{
return 20;
}
return i != 0 ? 21 : 22;
}
private static bool idempotency(LogicBranch paramLogicBranch)
{
var i = paramLogicBranch.Operator;
LogicExpression[] arrayOfLogicExpression = (LogicExpression[]) paramLogicBranch.Branches;
int j = arrayOfLogicExpression.Length;
for (int k = 0; k < arrayOfLogicExpression.Length; k++)
{
if ((arrayOfLogicExpression[k] == null) || (!(arrayOfLogicExpression[k] is LogicLeaf)))
continue;
var localLogicLeaf1 = (LogicLeaf) arrayOfLogicExpression[k];
for (int n = k + 1; n < arrayOfLogicExpression.Length; n++)
{
if ((arrayOfLogicExpression[n] == null) || (!(arrayOfLogicExpression[n] is LogicLeaf)))
continue;
var localLogicLeaf2 = (LogicLeaf) arrayOfLogicExpression[n];
if (!localLogicLeaf1.Name.Equals(localLogicLeaf2.Name))
continue;
if (arrayOfLogicExpression[k].Negated != arrayOfLogicExpression[n].Negated)
{
switch (i)
{
case Operator.And:
arrayOfLogicExpression[k] = new LogicValue(false);
break;
case Operator.Or:
arrayOfLogicExpression[k] = new LogicValue(true);
break;
default:
Console.Error.WriteLine("Software Error: Unimplemented operator: " + i);
break;
}
}
arrayOfLogicExpression[n] = null;
j--;
}
}
if (j == arrayOfLogicExpression.Length)
return false;
if (j == 1)
{
var localObject1 = paramLogicBranch.Parent;
if (localObject1 != null)
{
(localObject1).SetBranch(arrayOfLogicExpression[0], paramLogicBranch.PositionInParent);
}
return true;
}
var localObject = new LogicExpression[j];
j = 0;
foreach (LogicExpression t in arrayOfLogicExpression.Where(t => t != null))
{
localObject[j++] = t;
}
paramLogicBranch.Branches = localObject;
return true;
}
private static bool Distributivity(LogicBranch paramLogicBranch)
{
var i = paramLogicBranch.Operator;
LogicExpression[] arrayOfLogicExpression1 = paramLogicBranch.Branches;
var arrayOfLogicExpression = new LogicExpression[arrayOfLogicExpression1.Length][];
int j = 0;
int k = 1;
LogicExpression[] arrayOfLogicExpression2;
foreach (LogicExpression t in arrayOfLogicExpression1)
{
if ((t is LogicLeaf) || (t is LogicValue))
{
arrayOfLogicExpression2 = new[] {t};
arrayOfLogicExpression[(j++)] = arrayOfLogicExpression2;
}
else
{
arrayOfLogicExpression[j] = ((LogicBranch) t).Branches;
k *= arrayOfLogicExpression[j].Length;
j++;
}
}
if (k*arrayOfLogicExpression1.Length == j)
{
return false;
}
var arrayOfInt = new int[arrayOfLogicExpression.Length];
arrayOfInt[(arrayOfInt.Length - 1)] = -1;
arrayOfLogicExpression2 = new LogicExpression[k];
int n;
for (n = 0; n < arrayOfLogicExpression2.Length; n++)
{
arrayOfInt[(arrayOfInt.Length - 1)] += 1;
for (int i1 = arrayOfInt.Length - 1; i1 > 0; i1--)
{
if (arrayOfInt[i1] != arrayOfLogicExpression[i1].Length)
break;
arrayOfInt[i1] = 0;
arrayOfInt[(i1 - 1)] += 1;
}
var arrayOfLogicExpression3 = new LogicExpression[arrayOfLogicExpression.Length];
for (int i2 = 0; i2 < arrayOfLogicExpression3.Length; i2++)
{
arrayOfLogicExpression3[i2] = arrayOfLogicExpression[i2][arrayOfInt[i2]];
}
if (arrayOfLogicExpression3.Length == 1)
{
arrayOfLogicExpression2[n] = arrayOfLogicExpression3[0];
}
else
{
var localLogicBranch = new LogicBranch(i, false)
{
Branches = arrayOfLogicExpression3
};
arrayOfLogicExpression2[n] = localLogicBranch;
}
}
var nn = i == Operator.And ? Operator.Or : Operator.And;
paramLogicBranch.Branches = arrayOfLogicExpression2;
paramLogicBranch.Operator = nn;
return true;
}
private static void CarryOutBoolValues(LogicDerivation paramLogicDerivation)
{
var logicExpression = paramLogicDerivation.Next;
int i = logicExpression.GetDepth();
for (int m = 2; m <= i; m++)
{
int k = 0;
int j = 0;
LogicExpression localLogicExpression;
while ((localLogicExpression = logicExpression.GetSubExpression(m, j)) != null)
{
var localLogicBranch1 = (LogicBranch) localLogicExpression;
int n = GetBoolResolution(localLogicBranch1);
if (n == 31)
{
LogicExpression[] arrayOfLogicExpression = localLogicBranch1.Branches;
int i1 = arrayOfLogicExpression.Length;
i1 -= arrayOfLogicExpression.Count(t => (t is LogicValue));
if (i1 == 1)
{
LogicExpression localObject2 = arrayOfLogicExpression.FirstOrDefault(t => (!(t is LogicValue)));
LogicBranch localLogicBranch2 = localLogicExpression.Parent;
if (localLogicBranch2 == null)
{
logicExpression = localObject2;
localObject2.SetParent(null, -1);
}
else
{
localLogicBranch2.SetBranch(localObject2, localLogicExpression.PositionInParent);
}
}
else
{
var localObject22 = new LogicExpression[i1];
int i4 = 0;
foreach (LogicExpression t in arrayOfLogicExpression)
{
if (!(t is LogicValue))
{
localObject22[(i4++)] = t;
}
}
localLogicBranch1.Branches = localObject22;
j++;
}
k = 1;
}
else if ((n == 32) || (n == 33))
{
bool @bool = n == 32;
var localLogicValue = new LogicValue(@bool);
var localObject2 = localLogicBranch1.Parent;
if (localObject2 == null)
{
localLogicValue.SetParent(null, -1);
paramLogicDerivation.AddStep(localLogicValue, "Resolved bool values");
break;
}
(localObject2).SetBranch(localLogicValue, localLogicBranch1.PositionInParent);
k = 1;
}
else
{
j++;
}
}
if (k == 0)
continue;
paramLogicDerivation.AddStep(logicExpression, "Removed redundant bool values");
logicExpression = paramLogicDerivation.Next;
}
}
public override bool Equals(LogicExpression paramLogicExpression)
{
return ((paramLogicExpression is LogicValue)) &&
(((LogicValue) paramLogicExpression).EqualsTrue() == EqualsTrue());
}
private static int Absorbtion(LogicBranch paramLogicBranch)
{
LogicExpression[] arrayOfLogicExpression1 = paramLogicBranch.Branches;
int j = 0;
int m;
int n;
for (int k = 0; k < arrayOfLogicExpression1.Length - 1; k++)
{
for (m = k + 1; (m < arrayOfLogicExpression1.Length) && (arrayOfLogicExpression1[k] != null); m++)
{
if (arrayOfLogicExpression1[m] == null)
continue;
n = IsAbsorbtion(arrayOfLogicExpression1[k], arrayOfLogicExpression1[m]);
switch (n)
{
case 21:
arrayOfLogicExpression1[m] = null;
j++;
break;
case 22:
arrayOfLogicExpression1[k] = null;
j++;
break;
}
}
}
if (j > 0)
{
var arrayOfLogicExpression2 = new LogicExpression[arrayOfLogicExpression1.Length - j];
m = 0;
for (n = 0; n < arrayOfLogicExpression1.Length; n++)
{
if (arrayOfLogicExpression1[n] != null)
{
arrayOfLogicExpression2[(m++)] = arrayOfLogicExpression1[n];
}
}
paramLogicBranch.Branches = arrayOfLogicExpression2;
}
return j;
}
public void SetBranch(LogicExpression paramLogicExpression, int position)
{
_logicBranches[position] = paramLogicExpression;
paramLogicExpression.SetParent(this, position);
}
private static LogicExpression SplitWordsByOperator(String[] paramArrayOfString, int position, Operator paramInt2,
ParserSyntax paramParserSyntax)
{
int m;
if (position == 0)
throw new UnexpectedSymbolException("Operator at beginning of list of arguments");
if (position == paramArrayOfString.Length - 1)
{
throw new UnexpectedSymbolException("Operator at end of list of arguments");
}
if ((paramInt2 == Operator.Implies) || (paramInt2 == Operator.Biimplies) || (paramInt2 == Operator.Xor))
{
var arrayOfLogicExpression1 = new LogicExpression[2];
var arrayOfString1 = new String[position];
var arrayOfString2 = new String[paramArrayOfString.Length - position - 1];
for (m = 0; m < arrayOfString1.Length; m++)
{
arrayOfString1[m] = paramArrayOfString[m];
}
m = position + 1;
for (int n = 0; n < arrayOfString2.Length; n++)
{
arrayOfString2[n] = paramArrayOfString[(m++)];
}
arrayOfLogicExpression1[0] = ParseWords(arrayOfString1, paramParserSyntax);
arrayOfLogicExpression1[1] = ParseWords(arrayOfString2, paramParserSyntax);
var localLogicBranch1 = new LogicBranch(paramInt2, false) {Branches = arrayOfLogicExpression1};
return localLogicBranch1;
}
int i = 2;
for (int k = position - 1; k >= 0; k--)
{
Operator j = GetOperatorValue(paramArrayOfString[k]);
if (j == Operator.None)
continue;
if (j != paramInt2)
{
break;
}
paramParserSyntax.UpdateLogicSyntax(GetLogicSyntax(paramArrayOfString[k]));
i++;
}
var arrayOfLogicExpression2 = new LogicExpression[i];
m = paramArrayOfString.Length - 1;
for (int i2 = arrayOfLogicExpression2.Length - 1; i2 >= 0; i2--)
{
int i1 = 0;
int i3;
for (i3 = m; i3 >= 0; i3--)
{
var j = GetOperatorValue(paramArrayOfString[i3]);
if (j != paramInt2)
i1++;
else if (j == paramInt2)
{
break;
}
}
var arrayOfString3 = new String[i1];
i3 = m - i1;
int i4 = i1 - 1;
for (int i5 = m; i5 > i3; i5--)
{
arrayOfString3[(i4--)] = paramArrayOfString[i5];
}
m = m - i1 - 1;
arrayOfLogicExpression2[i2] = ParseWords(arrayOfString3, paramParserSyntax);
}
var localLogicBranch2 = new LogicBranch(paramInt2, false) {Branches = arrayOfLogicExpression2};
return localLogicBranch2;
}
public ParserBlock(LogicExpression paramLogicExpression, LogicSyntax paramInt1, NegationSyntax paramInt2)
{
Expression = paramLogicExpression;
LogicSyntax = paramInt1;
NegationSyntax = paramInt2;
}
private static bool associativity(LogicBranch paramLogicBranch)
{
LogicExpression[] arrayOfLogicExpression1 = paramLogicBranch.Branches;
int i = 0;
for (int j = 0; j < arrayOfLogicExpression1.Length; j++)
{
if (!(arrayOfLogicExpression1[j] is LogicBranch))
continue;
var localLogicBranch1 = (LogicBranch) arrayOfLogicExpression1[j];
if ((localLogicBranch1.Operator != paramLogicBranch.Operator) ||
localLogicBranch1.Negated)
{
continue;
}
i += localLogicBranch1.Branches.Length - 1;
}
if (i == 0)
{
return false;
}
var arrayOfLogicExpression2 = new LogicExpression[arrayOfLogicExpression1.Length + i];
int k = 0;
for (int m = 0; m < arrayOfLogicExpression1.Length; m++)
{
if ((arrayOfLogicExpression1[m] is LogicBranch))
{
var localLogicBranch2 = (LogicBranch) arrayOfLogicExpression1[m];
if ((localLogicBranch2.Operator == paramLogicBranch.Operator) &&
(!localLogicBranch2.Negated))
{
LogicExpression[] arrayOfLogicExpression3 = localLogicBranch2.Branches;
for (int n = 0; n < arrayOfLogicExpression3.Length; n++)
arrayOfLogicExpression2[(k++)] = arrayOfLogicExpression3[n];
}
else
{
arrayOfLogicExpression2[(k++)] = arrayOfLogicExpression1[m];
}
}
else
{
arrayOfLogicExpression2[(k++)] = arrayOfLogicExpression1[m];
}
}
paramLogicBranch.Branches = arrayOfLogicExpression2;
return true;
}
public override bool Equals(LogicExpression paramLogicExpression)
{
return ((paramLogicExpression is LogicLeaf)) && ((LogicLeaf) paramLogicExpression).Name.Equals(Name) &&
(paramLogicExpression.Negated == Negated);
}
public virtual bool Equals(LogicExpression paramLogicExpression)
{
return false;
}