Update app.py

app.py

@@ -23,7 +23,7 @@ sidebar_option = st.sidebar.radio("Select an option",
                                   "Drawing: Simple Path", "Drawing: Spectral Embedding", "Drawing: Traveling Salesman Problem",
                                   "Drawing: Weighted Graph", "3D Drawing: Animations of 3D Rotation", "3D Drawing: Basic Matplotlib",
                                   "Graph: DAG - Topological Layout", "Graph: Erdos Renyi", "Graph: Karate Club", "Graph: Minimum Spanning Tree",
-                                  "Graph: Triads", "Algorithms: Circuits"])
+                                  "Graph: Triads"])
 
 # Helper function to draw and display graph
 def draw_graph(G, pos=None, title="Graph Visualization"):
@@ -31,180 +31,6 @@ 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)
 
-# Define custom operators for logical OR, AND, and NOT
-def custom_or(a, b):
-    return Or(a, b)
-
-def custom_and(a, b):
-    return And(a, b)
-
-def custom_not(a):
-    return Not(a)
-
-# Function to convert the circuit to an equivalent formula.
-def circuit_to_formula(circuit):
-    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):
-        label = formula.nodes[root]["label"]
-        if not formula[root]:
-            return label
-        children = formula[root]
-        if len(children) == 1:
-            child = nx.utils.arbitrary_element(children)
-            return f"{label}({_to_string(formula, child)})"
-        left, right = formula[root]
-        left_subformula = _to_string(formula, left)
-        right_subformula = _to_string(formula, right)
-        return f"({left_subformula} {label} {right_subformula})"
-
-    root = next(v for v, d in formula.in_degree() if d == 0)
-    return _to_string(formula, root)
-
-# Main Streamlit application
-def algorithms_circuits():
-    st.title("Algorithms: Circuits")
-
-    # Option to choose between creating your own or using the default example
-    circuit_mode = st.radio(
-        "Choose a Mode:",
-        ("Default Example", "Create Your Own"),
-        help="The default example shows a predefined Boolean circuit, or you can create your own."
-    )
-
-    if circuit_mode == "Default Example":
-        # Define the default circuit as before
-        circuit = nx.DiGraph()
-        # Layer 0
-        circuit.add_node(0, label="∧", layer=0)
-        # Layer 1
-        circuit.add_node(1, label="∨", layer=1)
-        circuit.add_node(2, label="∨", layer=1)
-        circuit.add_edge(0, 1)
-        circuit.add_edge(0, 2)
-        # Layer 2
-        circuit.add_node(3, label="x", layer=2)
-        circuit.add_node(4, label="y", layer=2)
-        circuit.add_node(5, label="¬", layer=2)
-        circuit.add_edge(1, 3)
-        circuit.add_edge(1, 4)
-        circuit.add_edge(2, 4)
-        circuit.add_edge(2, 5)
-        # Layer 3
-        circuit.add_node(6, label="z", layer=3)
-        circuit.add_edge(5, 6)
-        # Convert the circuit to an equivalent formula.
-        formula = circuit_to_formula(circuit)
-        st.write("Formula: ", formula_to_string(formula))
-
-        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()
-
-    elif circuit_mode == "Create Your Own":
-        st.write("### Create Your Own Circuit")
-
-        # Text input for the Boolean expression
-        boolean_expression = st.text_input("Enter a Boolean expression (e.g., ((x or y) and (y or not(z)))):")
-
-        # Generate button
-        if st.button("Generate Circuit"):
-            if boolean_expression:
-                try:
-                    # Define symbols
-                    x, y, z = symbols('x y z')
-                    
-                    # Replace the custom characters with logical operators
-                    boolean_expression = boolean_expression.replace("∨", " or ").replace("∧", " and ").replace("¬", " not ")
-                    
-                    # Use eval to parse the input expression and replace symbols
-                    expr = eval(boolean_expression, {}, {
-                        "or": custom_or, "and": custom_and, "not": custom_not, "x": x, "y": y, "z": 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":
-    algorithms_circuits()
-
 def triads_graph():
     st.title("Graph: Triads")