diff --git a/vsp.py b/vsp.py
index 034005f..82baa4a 100644
--- a/vsp.py
+++ b/vsp.py
@@ -3,7 +3,7 @@ Check to see if the model has the variable
 sharing property.
 """
 from itertools import product
-from typing import List, Optional, Set, Tuple
+from typing import Dict, List, Optional, Set, Tuple
 from common import set_to_str
 from model import (
     Model, model_closure, ModelFunction, ModelValue
@@ -43,81 +43,46 @@ def has_vsp(model: Model, impfunction: ModelFunction,
     top = model.ordering.top()
     bottom = model.ordering.bottom()
 
-    # Compute I the set of tuples (x, y) where
-    # x -> y does not take a designiated value
-    I: List[Tuple[ModelValue, ModelValue]] = []
+    C: Dict[ModelValue, Set[ModelValue]] = {}
+    U: Dict[ModelValue, Set[ModelValue]] = {}
 
-    for (x, y) in product(model.designated_values, model.designated_values):
-        if impfunction(x, y) not in model.designated_values:
-            I.append((x, y))
-
-    # Find the subalgebras which falsify implication
-    for xys in I:
-
-        xi = xys[0]
+    for d in model.designated_values:
+        C[d] = model_closure({d,}, model.logical_operations, None)
+        U[d] = {y for y in model.designated_values if impfunction(d, y) in model.designated_values}
 
+    for x in model.designated_values:
+        Xs = C[x]
+        
         # Discard ({⊥} ∪ A', B) subalgebras
-        if bottom is not None and xi == bottom:
+        if bottom is not None and bottom in Xs:
             continue
-
+        
         # Discard ({⊤} ∪ A', B) subalgebras when negation is defined
-        if top is not None and negation_defined and xi == top:
+        if top is not None and negation_defined and top in Xs:
             continue
 
-        yi = xys[1]
+        Ux = U[x]
+        for y in model.designated_values - Xs - Ux:
+            Ys = C[y]
 
-        # Discard (A, {⊤} ∪ B') subalgebras
-        if top is not None and yi == top:
-            continue
-
-        # Discard (A, {⊥} ∪ B') subalgebras when negation is defined
-        if bottom is not None and negation_defined and yi == bottom:
-            continue
-
-        # Discard ({a} ∪ A', {b} ∪ B') subalgebras when a <= b
-        if model.ordering.is_lt(xi, yi):
-            continue
-
-        # Discard ({a} ∪ A', {b} ∪ B') subalgebras when b <= a and negation is defined
-        if negation_defined and model.ordering.is_lt(yi, xi):
-            continue
-
-        # Compute the left closure of the set containing xi under all the operations
-        carrier_set_left: Set[ModelValue] = model_closure({xi,}, model.logical_operations, bottom)
-
-        # Discard ({⊥} ∪ A', B) subalgebras
-        if bottom is not None and bottom in carrier_set_left:
-            continue
-
-        # Discard ({⊤} ∪ A', B) subalgebras when negation is defined
-        if top is not None and negation_defined and top in carrier_set_left:
-            continue
-
-        # Compute the closure of all operations
-        # with just the ys
-        carrier_set_right: Set[ModelValue] = model_closure({yi,}, model.logical_operations, top)
-
-        # Discard (A, {⊤} ∪ B') subalgebras
-        if top is not None and top in carrier_set_right:
-            continue
-
-        # Discard (A, {⊥} ∪ B') subalgebras when negation is defined
-        if bottom is not None and negation_defined and bottom in carrier_set_right:
-            continue
-
-        # Discard subalgebras that intersect
-        if not carrier_set_left.isdisjoint(carrier_set_right):
-            continue
-
-        # Check whether for all pairs in the subalgebra,
-        # that implication is falsified.
-        falsified = True
-        for (x2, y2) in product(carrier_set_left, carrier_set_right):
-            if impfunction(x2, y2) in model.designated_values:
-                falsified = False
-                break
-
-        if falsified:
-            return VSP_Result(True, model.name, carrier_set_left, carrier_set_right)
+            # Discard (A, {⊤} ∪ B') subalgebras
+            if top is not None and top in Ys:
+                continue
+            
+            # Discard (A, {⊥} ∪ B') subalgebras when negation is defined
+            if bottom is not None and negation_defined and bottom in Ys:
+                continue
+            
+            if not Xs.isdisjoint(Ys):
+                continue
 
+            falsified = True
+            for (xi, yi) in product(Xs, Ys):
+                if impfunction(xi, yi) in model.designated_values:
+                    falsified = False
+                    break
+            
+            if falsified:
+                return VSP_Result(True, model.name, Xs, Ys)
+    
     return VSP_Result(False, model.name)