+We encounter a challenge for the execution where the following holds:
+\path{r1 == 2 && r2 == 1 && r3 == 1 && r4 == 2}. For any total order that is
+consistent with the happens-before relation, that total order will be
+inconsistent with the modification order in either variable \code{x} or
+\code{y}. For example, if \code{y = 1} is ordered before \code{y = 2}, then
+\code{x = 1} is ordered before \code{x = 2} while \code{r1 = x} is ordered
+before \code{r2 = x}. As a result, we cannot possibly move up the second load
+operation \code{r2 = x} across \code{r1 = x} to generate a consistent sequential
+history. To solve this, one option is that allow loads to move up any operation
+including load and store operation on the same location. However, it is
+extremely conuter-intuitive for a later load operation to read an older value.
+By analysis, the problem here is that the store operations with different values
+to the same memory location are not ordered. This is actually a really rare case
+because it could be possible that only one store operation takes effect and all
+other store operations are useless. We believe that such case of blind stores
+from different threads is not the general pattern for concurrent data
+structures, and we believe that store operations are ordered. In terms of
+ordering points, we believe that in real-world data structures, store operations
+of ordering points are ordered by happens-before relation.
+\todo{argue why ordered stores are reasonable to concurrent data structures}
+
+We next define an action called \textit{tranform} that can be performed on the graph as