Update app.py

app.py

@@ -30,34 +30,50 @@ def draw_graph(G, pos=None, title="Graph Visualization"):
     nx.draw(G, pos=pos, with_labels=True, node_color='lightblue', node_size=500, font_size=10, font_weight='bold')
     st.pyplot(plt)
 
-def circuit_to_formula(circuit):
-    # Convert the circuit to an equivalent formula.
-    formula = nx.dag_to_branching(circuit)
-    # Transfer the operator or variable labels for each node from the
-    # circuit to the formula.
-    for v in formula:
-        source = formula.nodes[v]["source"]
-        formula.nodes[v]["label"] = circuit.nodes[source]["label"]
-    return formula
-
+# Function to convert a sympy Boolean expression to a graph
+def formula_to_circuit(formula):
+    circuit = nx.DiGraph()
+    node_id = 0
+    def add_formula_node(expr):
+        nonlocal node_id
+        # Create a unique node for each part of the formula
+        current_node = node_id
+        node_id += 1
+        circuit.add_node(current_node, label=str(expr))
+        return current_node
+
+    def build_circuit(expr):
+        if isinstance(expr, symbols):
+            # It's a variable, just return it as a node
+            return add_formula_node(expr)
+        elif isinstance(expr, Not):
+            # NOT operator
+            child = build_circuit(expr.args[0])
+            current_node = add_formula_node("¬")
+            circuit.add_edge(current_node, child)
+            return current_node
+        elif isinstance(expr, Or) or isinstance(expr, And):
+            # OR/AND operators
+            left = build_circuit(expr.args[0])
+            right = build_circuit(expr.args[1])
+            current_node = add_formula_node(str(expr.func))
+            circuit.add_edge(current_node, left)
+            circuit.add_edge(current_node, right)
+            return current_node
+
+    build_circuit(formula)
+    return circuit
+
+# Function to convert a formula graph to a string for display
 def formula_to_string(formula):
     def _to_string(formula, root):
-        # If there are no children, this is a variable node.
         label = formula.nodes[root]["label"]
         if not formula[root]:
             return label
-        # Otherwise, this is an operator.
         children = formula[root]
-        # If one child, the label must be a NOT operator.
         if len(children) == 1:
             child = nx.utils.arbitrary_element(children)
             return f"{label}({_to_string(formula, child)})"
-        # NB "left" and "right" here are a little misleading: there is
-        # no order on the children of a node. That's okay because the
-        # Boolean AND and OR operators are symmetric. It just means that the
-        # order of the operands cannot be predicted and hence the
-        # function does not necessarily behave the same way on every
-        # invocation.
         left, right = formula[root]
         left_subformula = _to_string(formula, left)
         right_subformula = _to_string(formula, right)
@@ -77,7 +93,7 @@ def algorithms_circuits():
     )
 
     if circuit_mode == "Default Example":
-        # Define the default circuit
+        # Define the default circuit as before
         circuit = nx.DiGraph()
         # Layer 0
         circuit.add_node(0, label="∧", layer=0)
@@ -119,46 +135,42 @@ def algorithms_circuits():
     elif circuit_mode == "Create Your Own":
         st.write("### Create Your Own Circuit")
 
-        # Let user input number of layers, nodes and edges for the circuit
-        num_layers = st.number_input("Number of layers:", min_value=1, value=3)
-        num_nodes = st.number_input("Number of nodes:", min_value=1, value=5)
-        num_edges = st.number_input("Number of edges:", min_value=1, value=3)
-
-        circuit = nx.DiGraph()
-
-        # Allow user to input labels and edges
-        for layer in range(num_layers):
-            for node in range(num_nodes):
-                label = st.text_input(f"Enter label for node ({layer}, {node}):", key=f"label_{layer}_{node}")
-                circuit.add_node(f"{layer}_{node}", label=label, layer=layer)
-
-        # Allow user to input edges between nodes
-        edges = []
-        for i in range(num_edges):
-            source = st.text_input(f"Enter source node for edge {i+1} (e.g., '0_1')", key=f"source_edge_{i}")
-            dest = st.text_input(f"Enter destination node for edge {i+1} (e.g., '1_2')", key=f"dest_edge_{i}")
-            edges.append((source, dest))
-        circuit.add_edges_from(edges)
-
-        # Create the formula based on the circuit
-        formula = circuit_to_formula(circuit)
-        st.write("Formula: ", formula_to_string(formula))
-
-        # Draw the circuit
-        labels = nx.get_node_attributes(circuit, "label")
-        options = {
-            "node_size": 600,
-            "alpha": 0.5,
-            "node_color": "blue",
-            "labels": labels,
-            "font_size": 22,
-        }
-        plt.figure(figsize=(8, 8))
-        pos = nx.multipartite_layout(circuit, subset_key="layer")
-        nx.draw_networkx(circuit, pos, **options)
-        plt.title(formula_to_string(formula))
-        plt.axis("equal")
-        st.pyplot()
+        # Text input for the Boolean expression
+        boolean_expression = st.text_input("Enter a Boolean expression (e.g., ((x ∨ y) ∧ (y ∨ ¬(z)))):")
+
+        # Generate button
+        if st.button("Generate Circuit"):
+            if boolean_expression:
+                try:
+                    # Parse the input expression
+                    expr = eval(boolean_expression, {}, {"Or": Or, "And": And, "Not": Not, "x": symbols('x'), "y": symbols('y'), "z": symbols('z')})
+                    
+                    # Convert the formula to a circuit
+                    circuit = formula_to_circuit(expr)
+
+                    # Display the formula as a string
+                    st.write("Formula: ", formula_to_string(circuit))
+
+                    # Visualize the circuit
+                    labels = nx.get_node_attributes(circuit, "label")
+                    options = {
+                        "node_size": 600,
+                        "alpha": 0.5,
+                        "node_color": "blue",
+                        "labels": labels,
+                        "font_size": 22,
+                    }
+                    plt.figure(figsize=(8, 8))
+                    pos = nx.multipartite_layout(circuit, subset_key="layer")
+                    nx.draw_networkx(circuit, pos, **options)
+                    plt.title(formula_to_string(circuit))
+                    plt.axis("equal")
+                    st.pyplot()
+
+                except Exception as e:
+                    st.error(f"Error parsing the expression: {e}")
+            else:
+                st.error("Please enter a valid Boolean expression.")
 
 # Display the corresponding page based on sidebar option
 if sidebar_option == "Algorithms: Circuits":