fix: isomorphism perf + LT model correctness

1. GraphIsomorphismAnalyzer: eliminate O(V) reverse-map rebuild per
   isFeasible() call. The backtracking search now maintains an
   incremental reverse mapping (graph2->graph1) alongside the forward
   mapping, reducing per-check cost from O(|mapping|) to O(1) for
   preimage lookups. On large graphs, this removes a major bottleneck
   from the inner loop of the VF2-style search.

2. InfluenceSpreadSimulator.simulateLT(): fix mid-round activation bug.
   Previously, nodes activated earlier in the iteration were visible to
   later nodes in the same round, causing order-dependent cascading.
   This violates the synchronous activation semantics of the Linear
   Threshold model. Now collects all activations first, then applies
   them simultaneously after evaluating all nodes.

Author: sauravbhattacharya001

Gvisual/src/gvisual/GraphIsomorphismAnalyzer.java

@@ -167,9 +167,10 @@ public int compare(String a, String b) {
 
         // Backtracking search
         Map<String, String> mapping = new LinkedHashMap<String, String>();
+        Map<String, String> reverseMapping = new HashMap<String, String>();
         Set<String> used2 = new HashSet<String>();
 
-        if (backtrack(vertices1, 0, mapping, used2, adj1, adj2, byDegree2)) {
+        if (backtrack(vertices1, 0, mapping, reverseMapping, used2, adj1, adj2, byDegree2)) {
             return new IsomorphismResult(true, mapping, null,
                     degSeq1, degSeq2);
         }
@@ -236,15 +237,22 @@ private Map<Integer, List<String>> groupByDegree(Graph<String, edge> g,
     }
 
     /**
-     * Backtracking search with degree-based candidate filtering.
+     * Backtracking search with degree-based candidate filtering and
+     * incremental reverse-mapping maintenance.
      *
      * For each vertex in graph1 (in order), try mapping it to each
      * candidate vertex in graph2 that has the same degree and hasn't
      * been used yet. Check feasibility (all already-mapped neighbors
      * must correspond) before recursing.
+     *
+     * <p>The reverse mapping (graph2 → graph1) is maintained incrementally
+     * alongside the forward mapping to avoid rebuilding it from scratch
+     * in every feasibility check — reducing per-check cost from O(|mapping|)
+     * to O(1) for the reverse lookup.</p>
      */
     private boolean backtrack(List<String> vertices1, int idx,
                               Map<String, String> mapping,
+                              Map<String, String> reverseMapping,
                               Set<String> used2,
                               Map<String, Set<String>> adj1,
                               Map<String, Set<String>> adj2,
@@ -264,16 +272,18 @@ private boolean backtrack(List<String> vertices1, int idx,
             // Feasibility check: for every neighbor of v1 that is
             // already mapped, the corresponding mapped vertex must
             // be a neighbor of v2
-            if (isFeasible(v1, v2, mapping, adj1, adj2)) {
+            if (isFeasible(v1, v2, mapping, reverseMapping, adj1, adj2)) {
                 mapping.put(v1, v2);
+                reverseMapping.put(v2, v1);
                 used2.add(v2);
 
-                if (backtrack(vertices1, idx + 1, mapping, used2,
-                        adj1, adj2, byDegree2)) {
+                if (backtrack(vertices1, idx + 1, mapping, reverseMapping,
+                        used2, adj1, adj2, byDegree2)) {
                     return true;
                 }
 
                 mapping.remove(v1);
+                reverseMapping.remove(v2);
                 used2.remove(v2);
             }
         }
@@ -288,9 +298,13 @@ private boolean backtrack(List<String> vertices1, int idx,
      * the mapped vertex mapping[n1] must be a neighbor of v2.
      * Also, for every neighbor n2 of v2 whose preimage is mapped,
      * the preimage must be a neighbor of v1.
+     *
+     * <p>Uses the incrementally-maintained reverse mapping for O(1)
+     * preimage lookups instead of rebuilding it from scratch each call.</p>
      */
     private boolean isFeasible(String v1, String v2,
                                 Map<String, String> mapping,
+                                Map<String, String> reverseMapping,
                                 Map<String, Set<String>> adj1,
                                 Map<String, Set<String>> adj2) {
         Set<String> neighbors1 = adj1.get(v1);
@@ -305,12 +319,8 @@ private boolean isFeasible(String v1, String v2,
         }
 
         // Reverse check: mapped neighbors of v2 must come from neighbors of v1
-        Map<String, String> reverse = new HashMap<String, String>();
-        for (Map.Entry<String, String> entry : mapping.entrySet()) {
-            reverse.put(entry.getValue(), entry.getKey());
-        }
         for (String n2 : neighbors2) {
-            String preimage = reverse.get(n2);
+            String preimage = reverseMapping.get(n2);
             if (preimage != null && !neighbors1.contains(preimage)) {
                 return false;
             }

Gvisual/src/gvisual/InfluenceSpreadSimulator.java

@@ -108,6 +108,14 @@ public SimulationResult simulateIC(Collection<String> seeds,
 
     // ─── Linear Threshold ───────────────────────────────────────
 
+    /**
+     * Linear Threshold simulation.
+     *
+     * <p>Uses synchronous activation: all nodes are evaluated against
+     * the current round's state, and newly activated nodes only become
+     * visible in the next round.  This prevents activation order within
+     * a single round from affecting results.</p>
+     */
     public SimulationResult simulateLT(Collection<String> seeds, int maxRounds) {
         validateSeeds(seeds);
 
@@ -129,33 +137,47 @@ public SimulationResult simulateLT(Collection<String> seeds, int maxRounds) {
             if (maxRounds > 0 && round > maxRounds) break;
             changed = false;
 
+            // Collect all activations for this round before applying any
+            List<String> toActivate = new ArrayList<>();
+            Map<String, String> activatedBy = new LinkedHashMap<>();
+
             for (String node : graph.getVertices()) {
                 if (state.get(node) != NodeState.SUSCEPTIBLE) continue;
 
                 Collection<String> neighbors = getNeighbors(node);
                 if (neighbors.isEmpty()) continue;
 
                 int activeNeighbors = 0;
+                String anActiveNeighbor = null;
                 for (String neighbor : neighbors) {
                     if (state.get(neighbor) == NodeState.INFECTED ||
                         state.get(neighbor) == NodeState.RECOVERED) {
                         activeNeighbors++;
+                        if (anActiveNeighbor == null) {
+                            anActiveNeighbor = neighbor;
+                        }
                     }
                 }
 
                 double fraction = (double) activeNeighbors / neighbors.size();
                 if (fraction >= thresholds.get(node)) {
-                    state.put(node, NodeState.INFECTED);
-                    changed = true;
-                    for (String neighbor : neighbors) {
-                        if (state.get(neighbor) == NodeState.INFECTED ||
-                            state.get(neighbor) == NodeState.RECOVERED) {
-                            timeline.add(new InfectionEvent(neighbor, node, round));
-                            break;
-                        }
+                    toActivate.add(node);
+                    if (anActiveNeighbor != null) {
+                        activatedBy.put(node, anActiveNeighbor);
                     }
                 }
             }
+
+            // Apply all activations simultaneously
+            for (String node : toActivate) {
+                state.put(node, NodeState.INFECTED);
+                changed = true;
+                String source = activatedBy.get(node);
+                if (source != null) {
+                    timeline.add(new InfectionEvent(source, node, round));
+                }
+            }
+
             snapshots.add(createSnapshot(round, state));
         }