C# 布尔代数表达式分解

我正在为一个项目用C#创建一个布尔代数简化器。为了简化布尔代数表达式，我采用以下方法：

1） 简化每个变量的NOT，并在适用的情况下应用德摩根定律

2） 简化表达式中的括号（如果有）

3） 展开表达式中可以展开的任何括号

4） 简化表达式中的每个术语，例如，对于表达式A+B•A，B•A将是一个术语。这些项被拆分，以便每个项只包含一个门和或异或。NOT应用于这些变量，并在与数组中每个变量的索引相对应的列表中表示。例如，Nots[0]包含表达式中第一个变量上的Nots数。在我的程序中，没有变量通过非门连接

5） 在可能的情况下进行因式分解

6） 如果表达式不能被分解，那么它已经被简化了。如果它已被分解，则重复步骤2，直到表达式在执行这些步骤时不变

我无法创建适用于所有/大多数情况的因式分解子程序。我已经创建了一个子例程进行分解，并将其放在下面。我试图使它只扩展最多两个括号，并且括号中没有括号，以使我的子例程更容易创建。然而，创建这样一个算法对我来说是相当困难的

如果有人能提供一些伪代码，或解释如何创建这样一个算法，指出我代码中的错误，甚至提供一些我可以分析和理解的代码，我将不胜感激。代码如下所示：（警告：这是可怕的编程，因为我缺乏经验。）

private bool factorse（ref List表达式，ref List NOTsNew）
{
string PreviousExpression=convertexpressionlisttostring（表达式）；
//循环并获取每个单独的变量-无重复项
//遍历每个变量的表达式，查看它是否出现多次
List ITEMSTHATAPEARWITHINEXPRESSION=新列表（）；
List charactersthappearwithinexpression=new List（）；
列出NotSofCharactersThat happearWithInExpression=new List（）；
List NumberOfTimeCharacterDisplays=新列表（）；
项目的列表位置Swithinexpression=新列表（）；
itemsthatpearwithinexpression.Add（charactersthatpearwithinexpression）；
添加（不包括未表达的字符）；
显示为InExpression.Add的项目（项目在InExpression中的位置）；
显示为InExpression.Add的项（显示NumberOfTimeCharacter）；
for（int i=0；iprivate bool Factorise(ref List<string> Expression, ref List<int> NOTsNew)
{
        string PreviousExpression = convertexpressionlisttostring(Expression);
        // loop and get each indiviual variable - no duplicates 
        // loop through expression for every variable and see if it occurs more than once 

        List<List<string>> itemsthatappearwithinexpression = new List<List<string>>();
        List<string> charactersthatappearwithinexpression = new List<string>();
        List<string> Notsofcharactersthathappearwithinexpression = new List<string>();
        List<string> numberoftimescharacterappears = new List<string>();
        List<string> positionofitemswithinexpression = new List<string>();
        itemsthatappearwithinexpression.Add(charactersthatappearwithinexpression);
        itemsthatappearwithinexpression.Add(Notsofcharactersthathappearwithinexpression);
        itemsthatappearwithinexpression.Add(positionofitemswithinexpression);
        itemsthatappearwithinexpression.Add(numberoftimescharacterappears);

        for (int i = 0; i < Expression.Count; i++)
        {
            if (Expression[i] != "•" && Expression[i] != "+" && Expression[i] != "⊕")
            {
                if (itemsthatappearwithinexpression[0].Count == 0)
                {
                    itemsthatappearwithinexpression[0].Add(Expression[i]);
                    itemsthatappearwithinexpression[1].Add(NOTsNew[i].ToString());
                    itemsthatappearwithinexpression[2].Add(i.ToString());
                }
                bool matched = false;
                for (int y = 0; y < itemsthatappearwithinexpression[0].Count; y++)
                {
                    if (itemsthatappearwithinexpression[0][y] == Expression[i] && itemsthatappearwithinexpression[1][y] == NOTsNew[i].ToString())
                    {
                        matched = true;
                        break;
                    }
                }
                if (!matched)
                {
                    itemsthatappearwithinexpression[0].Add(Expression[i]);
                    itemsthatappearwithinexpression[1].Add(NOTsNew[i].ToString());
                    itemsthatappearwithinexpression[2].Add(i.ToString());
                }
            }

        }
        for (int x = 0; x < itemsthatappearwithinexpression[0].Count; x++)
        {
            int occurances = 1;
            for (int c = 0; c < Expression.Count; c++)
            {
                int position = int.Parse(itemsthatappearwithinexpression[2][x]);
                if (NOTsNew[c] == NOTsNew[position] && c != position && itemsthatappearwithinexpression[0][x] == Expression[c])
                {
                    occurances++;
                }
            }
            itemsthatappearwithinexpression[3].Add(occurances.ToString());
        }
        for (int i = 0; i < itemsthatappearwithinexpression[0].Count; i++)
        {
            if (i < itemsthatappearwithinexpression[0].Count - 1)
            {
                if (itemsthatappearwithinexpression[3][i] == itemsthatappearwithinexpression[3][i + 1] && int.Parse(itemsthatappearwithinexpression[2][i]) == (int.Parse(itemsthatappearwithinexpression[2][i + 1]) - 2))
                {
                    itemsthatappearwithinexpression[0][i] = itemsthatappearwithinexpression[0][i].ToString() + itemsthatappearwithinexpression[0][i + 1].ToString(); // chars, nots, position, occurances
                    itemsthatappearwithinexpression[1][i] = itemsthatappearwithinexpression[1][i].ToString() + itemsthatappearwithinexpression[1][i + 1].ToString(); // Nots[0]

                    itemsthatappearwithinexpression[0].RemoveAt(i + 1);
                    itemsthatappearwithinexpression[1].RemoveAt(i + 1);
                    itemsthatappearwithinexpression[2].RemoveAt(i + 1);
                    itemsthatappearwithinexpression[3].RemoveAt(i + 1);
                }
            }
        }
        List<int> positionsoffirstcharinmatches = new List<int>();
        string factorisedexpression = "";
        bool donextthing = false;
        List<int> NOTsinfactorisation = new List<int>();

        for (int d = 0; d < itemsthatappearwithinexpression[0].Count; d++)
        {
            int counter = 0;
            bool singularexpansion = false;
            if (itemsthatappearwithinexpression[0][d].Length == 1)
            {
                singularexpansion = true;
            }
            if (int.Parse(itemsthatappearwithinexpression[3][d]) > 1)
            {
                for (int i = 0; i < Expression.Count; i++)
                {
                    bool Continue = false;
                    if (singularexpansion && Expression[i] == itemsthatappearwithinexpression[0][d] && NOTsNew[i] == NOTsNew[int.Parse(itemsthatappearwithinexpression[2][d])])
                    {
                        Continue = true;
                    }
                    if (i+2 <= Expression.Count-1 && !singularexpansion && Expression[i] == itemsthatappearwithinexpression[0][d][0].ToString() && Expression[i+2] == itemsthatappearwithinexpression[0][d][1].ToString() && NOTsNew[i] == int.Parse(itemsthatappearwithinexpression[1][d][0].ToString()) && NOTsNew[i+2] == int.Parse(itemsthatappearwithinexpression[1][d][1].ToString()))
                    {
                        Continue = true;
                    }
                    donextthing = false;
                    if (Continue)
                    {
                        if (i != 0)
                        {
                            if (Expression[i - 1] == "•")
                            {
                                positionsoffirstcharinmatches.Add(i - 2);
                                if (counter == 0)
                                {
                                    if (singularexpansion)
                                    {

                                        factorisedexpression += itemsthatappearwithinexpression[0][d] + "•(" + Expression[i - 2] + Expression[i - 3];
                                        NOTsinfactorisation.Add(int.Parse(itemsthatappearwithinexpression[1][d]));
                                        NOTsinfactorisation.Add(0);
                                        NOTsinfactorisation.Add(0);
                                        NOTsinfactorisation.Add(NOTsNew[i - 2]);
                                        NOTsinfactorisation.Add(0);
                                        counter++;
                                    }
                                    else
                                    {
                                        positionsoffirstcharinmatches.Add(i);
                                        factorisedexpression += itemsthatappearwithinexpression[0][d][0] + "•" + itemsthatappearwithinexpression[0][d][1] + "•(" + Expression[i - 2] + Expression[i - 3];
                                        //string NOTsOfAdjacentVariables = itemsthatappearwithinexpression[1][d]; 
                                        NOTsinfactorisation.Add(int.Parse(itemsthatappearwithinexpression[1][d][0].ToString()));
                                        NOTsinfactorisation.Add(0);
                                        NOTsinfactorisation.Add(int.Parse(itemsthatappearwithinexpression[1][d][1].ToString()));
                                        NOTsinfactorisation.Add(0);
                                        NOTsinfactorisation.Add(0);
                                        NOTsinfactorisation.Add(NOTsNew[i - 2]);
                                        NOTsinfactorisation.Add(0);
                                        counter++;
                                    }

                                }
                                else
                                {
                                    if (i >= Expression.Count - 3)
                                    {
                                        factorisedexpression += Expression[i - 2] + ")";
                                        NOTsinfactorisation.Add(NOTsNew[i - 2]);
                                        NOTsinfactorisation.Add(0);
                                    }
                                    else
                                    {
                                        factorisedexpression += Expression[i + 3] + Expression[i + 2];
                                        NOTsinfactorisation.Add(0);
                                        NOTsinfactorisation.Add(NOTsNew[i + 2]);
                                    }
                                }
                            }
                            else
                            {
                                donextthing = true;
                            }
                        }
                        else
                        {
                            donextthing = true;
                        }
                        if (donextthing)
                        {
                            positionsoffirstcharinmatches.Add(i);
                            if (counter == 0)
                            {
                                if (singularexpansion)
                                {
                                    positionsoffirstcharinmatches.Add(i + 2);
                                    factorisedexpression += itemsthatappearwithinexpression[0][d] + "•(" + Expression[i + 2] + Expression[i + 3];
                                    NOTsinfactorisation.Add(int.Parse(itemsthatappearwithinexpression[1][d]));
                                    NOTsinfactorisation.Add(0);
                                    NOTsinfactorisation.Add(0);
                                    NOTsinfactorisation.Add(NOTsNew[i + 2]);
                                    NOTsinfactorisation.Add(0);
                                    counter++;
                                }
                                else
                                {
                                    bool useone = false;
                                    if (Expression[i]+Expression[i+2] == itemsthatappearwithinexpression[0][d] || Expression[i + 2] + Expression[i] == itemsthatappearwithinexpression[0][d])
                                    {
                                        useone = true;
                                    }
                                    positionsoffirstcharinmatches.Add(i+2);
                                    if (useone)
                                    {
                                        factorisedexpression += itemsthatappearwithinexpression[0][d][0] + "•" + itemsthatappearwithinexpression[0][d][1] + "•(" + "1" + Expression[i + 3];

                                    }
                                    else
                                    {
                                        factorisedexpression += itemsthatappearwithinexpression[0][d][0] + "•" + itemsthatappearwithinexpression[0][d][1] + "•(" + Expression[i + 2] + Expression[i + 3];

                                    }
                                    //string NOTsOfAdjacentVariables = itemsthatappearwithinexpression[1][d]; 
                                    NOTsinfactorisation.Add(int.Parse(itemsthatappearwithinexpression[1][d][0].ToString()));
                                    NOTsinfactorisation.Add(0);
                                    NOTsinfactorisation.Add(int.Parse(itemsthatappearwithinexpression[1][d][1].ToString()));
                                    NOTsinfactorisation.Add(0);
                                    NOTsinfactorisation.Add(0);
                                    if (useone)
                                    {
                                        NOTsinfactorisation.Add(0);
                                    }
                                    else
                                    {
                                        NOTsinfactorisation.Add(NOTsNew[i + 2]);
                                    }

                                    NOTsinfactorisation.Add(0);
                                    counter++;
                                }
                            }
                            else
                            {
                                if (i == Expression.Count - 3)
                                {

                                    if (Expression[i]+Expression[i+2] == itemsthatappearwithinexpression[0][d] || Expression[i + 2] + Expression[i] == itemsthatappearwithinexpression[0][d])
                                    {
                                        factorisedexpression += "1" + ")";
                                        NOTsinfactorisation.Add(0);

                                    }
                                    else
                                    {
                                        factorisedexpression += Expression[i + 2] + ")";
                                        NOTsinfactorisation.Add(NOTsNew[i + 2]);
                                    }
                                    NOTsinfactorisation.Add(0);
                                }
                                else
                                {
                                    factorisedexpression += Expression[i + 3] + Expression[i + 2];
                                    NOTsinfactorisation.Add(0);
                                    NOTsinfactorisation.Add(NOTsNew[i + 2]);
                                }

                            }
                        }
                    }

                }
            }
            else
            {

            }
        }
        // character • ()  --> A•B + A•C Xor A•D = A•(B+C XOR D) - find every instance of the object - get the operator before the object and  place the o
        //int n = 5; //Expression
        positionsoffirstcharinmatches = intbubblesorthightolow(positionsoffirstcharinmatches);
        List<int> PositionstoremovefromExpression = new List<int>();
        for (int i = 0; i < positionsoffirstcharinmatches.Count; i++)
        {
            if (positionsoffirstcharinmatches[i] < Expression.Count - 3)
            {
                PositionstoremovefromExpression.Add(positionsoffirstcharinmatches[i] + 3);
                PositionstoremovefromExpression.Add(positionsoffirstcharinmatches[i] + 2);
                PositionstoremovefromExpression.Add(positionsoffirstcharinmatches[i] + 1);
                PositionstoremovefromExpression.Add(positionsoffirstcharinmatches[i]);
            }
            else
            {
                PositionstoremovefromExpression.Add(positionsoffirstcharinmatches[i] + 2);
                PositionstoremovefromExpression.Add(positionsoffirstcharinmatches[i] + 1);
                PositionstoremovefromExpression.Add(positionsoffirstcharinmatches[i]);
            }

        }

        PositionstoremovefromExpression = intbubblesorthightolow(PositionstoremovefromExpression);
        PositionstoremovefromExpression = PositionstoremovefromExpression.Distinct().ToList();
        for (int i = 0; i < PositionstoremovefromExpression.Count; i++)
        {
            NOTsNew.RemoveAt(PositionstoremovefromExpression[i]);
            Expression.RemoveAt(PositionstoremovefromExpression[i]); // A • B + C • A
        }
        for (int i = 0; i < factorisedexpression.Length; i++)
        {
            try
            {
                Expression[PositionstoremovefromExpression[PositionstoremovefromExpression.Count - 1] + i] = factorisedexpression[i].ToString();
                NOTsNew[PositionstoremovefromExpression[PositionstoremovefromExpression.Count - 1] + i] = NOTsinfactorisation[i];
            }
            catch (Exception)
            {
                Expression.Add(factorisedexpression[i].ToString());
                NOTsNew.Add(NOTsinfactorisation[i]);
            }

        }
        if (PreviousExpression == convertexpressionlisttostring(Expression))
        {
            return false;
        }
        else
        {
            return true;
        }

    }

abstract class Token { ... }
sealed class IdentifierToken : Token { ... }
sealed class NotToken : Token { ... }
sealed class OrToken : Token { ... }
sealed class AndToken : Token { ... }
sealed class LeftParenToken : Token { ... }
sealed class RightParenToken : Token { ... }
sealed class TrueToken : Token { ... }
sealed class FalseToken : Token { ... }

public static List<Token> Lexer(string s) { ... }

abstract class ParseNode { ... }
sealed class OrNode : ParseNode 
{ 
  public ParseNode Left { get; }
  public ParseNode Right { get; }
  ...
  // Or maybe IEnumerable<ParseNode> Children { get; }
  // is easier; both techniques have their strengths.
}
sealed class AndNode : ParseNode { ... }
sealed class NotNode : ParseNode { ... }
sealed class IdentifierNode : ParseNode { ... }
sealed class TrueNode : ParseNode { ... }
sealed class FalseNode : ParseNode { ... }

         And
       /     \
     Or     Id(C)
   /   \
 Id(A) Not
         |
       Id(B)

public static ParseNode Parser(List<Token> tokens) { ... }

EXPR    : OREX
OREX    : ANDEX ORTAIL
ORTAIL  : NIL
ORTAIL  : + ANDEX ORTAIL
ANDEX   : NOTEX ANDTAIL
ANDTAIL : NIL
ANDTAIL : * NOTEX ANDTAIL
NOTEX   : CONST
NOTEX   : ( EXPR )
NOTEX   : ~ NOTEX
NOTEX   : IDENT
IDENT   : <any single letter>
CONST   : 1
CONST   : 0

public static ParseNode FooOptimization(ParseNode p) { ... }
public static ParseNode BarOptimization(ParseNode p) { ... }

public static ParseNode NotFalseOptimization(ParseNode p)
{
  if (p is NotNode n)
  {  
    // The child might itself have a Not(False) somewhere in it.
    ParseNode child = NotFalseOptimization(n.Child);
    if (child is FalseNode)
      return new TrueNode();
    else
      return new NotNode(child);
  }
  else if (p is OrNode o)
    return new OrNode(NotFalseOptimization(o.Left), NotFalseOptimization(o.Right);
  else if (p is AndNode a)
    return new AndNode(NotFalseOptimization(a.Left), NotFalseOptimization(a.Right);
  else
     return p;
}

static string DoItAll(string s) 
{
  var tokens = Lex(s);
  var tree = Parse(tokens);
  var optimized = Optimize(tree);
  return optimized.ToString();
}