G-single-item-realtime #0
Let:
  T1 = {:index 442102, :time 938423167367, :type :ok, :process 7, :f :txn, :value [[:r 6488 nil]]}
  T2 = {:index 442034, :time 938278883105, :type :ok, :process 5, :f :txn, :value [[:append 6488 1] [:r 6473 [1 3 5 15 16 44 47 48 55 51 54 63 61 62 59 68 70 74 73 85 84 88 93 91 92 94 101 104 106 107 108 110 119]]]}
  T3 = {:index 442062, :time 938365685480, :type :ok, :process 2, :f :txn, :value [[:append 6488 2] [:append 6488 3]]}
  T4 = {:index 442090, :time 938401311114, :type :ok, :process 1, :f :txn, :value [[:append 6488 27]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 6488, which T2 created by appending 1.
  - T2 < T3, because T3 appended 2 after T2 appended 1 to 6488.
  - T3 < T4, because T4 appended 27 after T3 appended 3 to 6488.
  - However, T4 < T1, because T4 completed at index 442090, 0.022 seconds before the invocation of T1, at index 442101: a contradiction!


G-single-item-realtime #1
Let:
  T1 = {:index 67000, :time 137318026976, :type :ok, :process 7, :f :txn, :value [[:r 941 nil]]}
  T2 = {:index 66960, :time 137214021277, :type :ok, :process 6, :f :txn, :value [[:append 941 2] [:r 939 [4 10 8 9 19 23]]]}
  T3 = {:index 66968, :time 137224388968, :type :ok, :process 6, :f :txn, :value [[:append 941 4] [:append 920 20]]}
  T4 = {:index 66978, :time 137262146596, :type :ok, :process 3, :f :txn, :value [[:append 939 27] [:r 939 [4 10 8 9 19 23 27]] [:r 939 [4 10 8 9 19 23 27]]]}
  T5 = {:index 66986, :time 137299083878, :type :ok, :process 7, :f :txn, :value [[:append 939 30] [:r 856 [2 8 14 12 13 15 18 28 32 35 39 42 40 44 45 53 56 57 60 62 64 65 66 70 72 73 75 80 83 85 86 89 91 95 98 100 102 104 107 110 111]] [:append 939 31]]}
  T6 = {:index 66992, :time 137306665011, :type :ok, :process 7, :f :txn, :value [[:r 892 [4 7 10 15 20 23 24 25 26 33 34]] [:append 912 100]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 941, which T2 created by appending 2.
  - T2 < T3, because T3 appended 4 after T2 appended 2 to 941.
  - T3 < T4, because T3 completed at index 66968, 0.012 seconds before the invocation of T4, at index 66973.
  - T4 < T5, because T5 appended 30 after T4 appended 27 to 939.
  - T5 < T6, because T5 completed at index 66986, 0.000 seconds before the invocation of T6, at index 66987.
  - However, T6 < T1, because T6 completed at index 66992, 0.000 seconds before the invocation of T1, at index 66993: a contradiction!


G-single-item-realtime #2
Let:
  T1 = {:index 1378222, :time 3601223652993, :type :ok, :process 14, :f :txn, :value [[:r 20054 nil]]}
  T2 = {:index 1378048, :time 3600604690477, :type :ok, :process 1, :f :txn, :value [[:append 20052 9] [:append 20054 1]]}
  T3 = {:index 1378072, :time 3600710723532, :type :ok, :process 0, :f :txn, :value [[:append 20052 13]]}
  T4 = {:index 1378160, :time 3601035000651, :type :ok, :process 0, :f :txn, :value [[:append 20052 20] [:r 20054 [1 4 2 17 22 20 21 25 27 36]]]}
  T5 = {:index 1378178, :time 3601075314341, :type :ok, :process 2, :f :txn, :value [[:append 20052 23]]}
  T6 = {:index 1378210, :time 3601206667849, :type :ok, :process 7, :f :txn, :value [[:append 20054 54]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 20054, which T2 created by appending 1.
  - T2 < T3, because T3 appended 13 after T2 appended 9 to 20052.
  - T3 < T4, because T4 appended 20 after T3 appended 13 to 20052.
  - T4 < T5, because T5 appended 23 after T4 appended 20 to 20052.
  - T5 < T6, because T5 completed at index 1378178, 0.021 seconds before the invocation of T6, at index 1378183.
  - However, T6 < T1, because T6 completed at index 1378210, 0.011 seconds before the invocation of T1, at index 1378217: a contradiction!


G-single-item-realtime #3
Let:
  T1 = {:index 1373352, :time 3583634611993, :type :ok, :process 3, :f :txn, :value [[:r 19973 nil]]}
  T2 = {:index 1372908, :time 3581808927268, :type :ok, :process 15, :f :txn, :value [[:append 19973 1]]}
  T3 = {:index 1372950, :time 3581974217436, :type :ok, :process 6, :f :txn, :value [[:append 19973 6] [:r 19970 [3 4 10 13 14 18 36 37 40]]]}
  T4 = {:index 1373002, :time 3582187714758, :type :ok, :process 6, :f :txn, :value [[:append 19973 7] [:append 19964 40] [:r 19964 [1 4 9 11 12 15 19 22 25 30 37 40]] [:append 19956 37]]}
  T5 = {:index 1373021, :time 3582223384631, :type :ok, :process 19, :f :txn, :value [[:append 19956 38] [:append 19970 76]]}
  T6 = {:index 1373330, :time 3583525731733, :type :ok, :process 14, :f :txn, :value [[:append 19956 49] [:append 19977 6] [:append 19950 16]]}
  T7 = {:index 1373338, :time 3583553746252, :type :ok, :process 3, :f :txn, :value [[:r 19964 [1 4 9 11 12 15 19 22 25 30 37 40 44 47 49 56]] [:r 19973 [1 6 7 15 16 22 21 27 31 36 38 41 39]]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 19973, which T2 created by appending 1.
  - T2 < T3, because T3 appended 6 after T2 appended 1 to 19973.
  - T3 < T4, because T4 appended 7 after T3 appended 6 to 19973.
  - T4 < T5, because T5 appended 38 after T4 appended 37 to 19956.
  - T5 < T6, because T6 appended 49 after T5 appended 38 to 19956.
  - T6 < T7, because T6 completed at index 1373330, 0.002 seconds before the invocation of T7, at index 1373335.
  - However, T7 < T1, because T7 completed at index 1373338, 0.000 seconds before the invocation of T1, at index 1373339: a contradiction!


G-single-item-realtime #4
Let:
  T1 = {:index 937038, :time 2185934107340, :type :ok, :process 9, :f :txn, :value [[:r 13767 nil]]}
  T2 = {:index 936994, :time 2185837273711, :type :ok, :process 1, :f :txn, :value [[:append 13767 2]]}
  T3 = {:index 937024, :time 2185903937397, :type :ok, :process 3, :f :txn, :value [[:r 13767 [2]] [:append 13764 17]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 13767, which T2 created by appending 2.
  - T2 < T3, because T3 observed T2's append of 2 to key 13767.
  - However, T3 < T1, because T3 completed at index 937024, 0.000 seconds before the invocation of T1, at index 937027: a contradiction!


G-single-item-realtime #5
Let:
  T1 = {:index 538, :time 2822514098, :type :ok, :process 5, :f :txn, :value [[:append 17 2]]}
  T2 = {:index 566, :time 2864330206, :type :ok, :process 1, :f :txn, :value [[:r 17 nil]]}

Then:
  - T1 < T2, because T1 completed at index 538, 0.005 seconds before the invocation of T2, at index 547.
  - However, T2 < T1, because T2 observed the initial (nil) state of 17, which T1 created by appending 2: a contradiction!


G-single-item-realtime #6
Let:
  T1 = {:index 936604, :time 2184677817110, :type :ok, :process 5, :f :txn, :value [[:r 13756 nil]]}
  T2 = {:index 936578, :time 2184623532614, :type :ok, :process 14, :f :txn, :value [[:append 13756 6] [:r 13756 [6]]]}
  T3 = {:index 936588, :time 2184653209921, :type :ok, :process 2, :f :txn, :value [[:append 13759 4] [:append 13759 5]]}
  T4 = {:index 936599, :time 2184671639658, :type :ok, :process 8, :f :txn, :value [[:r 13759 [4 5]]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 13756, which T2 created by appending 6.
  - T2 < T3, because T2 completed at index 936578, 0.011 seconds before the invocation of T3, at index 936583.
  - T3 < T4, because T4 observed T3's append of 5 to key 13759.
  - However, T4 < T1, because T4 completed at index 936599, 0.000 seconds before the invocation of T1, at index 936600: a contradiction!


G-single-item-realtime #7
Let:
  T1 = {:index 442136, :time 938517712601, :type :ok, :process 7, :f :txn, :value [[:r 6489 nil]]}
  T2 = {:index 442130, :time 938509322171, :type :ok, :process 9, :f :txn, :value [[:append 6473 131] [:append 6489 4]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 6489, which T2 created by appending 4.
  - However, T2 < T1, because T2 completed at index 442130, 0.008 seconds before the invocation of T1, at index 442135: a contradiction!


G-single-item-realtime #8
Let:
  T1 = {:index 1371721, :time 3577835160324, :type :ok, :process 8, :f :txn, :value [[:r 19953 nil]]}
  T2 = {:index 1371564, :time 3577219446347, :type :ok, :process 14, :f :txn, :value [[:append 19953 1]]}
  T3 = {:index 1371584, :time 3577336437818, :type :ok, :process 19, :f :txn, :value [[:r 19953 [1]] [:append 19946 51]]}
  T4 = {:index 1371602, :time 3577392571448, :type :ok, :process 14, :f :txn, :value [[:r 19953 [1 10]] [:r 19946 [3 17 23 26 29 33 37 44 47 48 51]] [:r 19953 [1 10]]]}
  T5 = {:index 1371646, :time 3577567348610, :type :ok, :process 3, :f :txn, :value [[:append 19946 55] [:append 19953 29] [:append 19904 57]]}
  T6 = {:index 1371702, :time 3577758286980, :type :ok, :process 2, :f :txn, :value [[:r 19953 [1 10 14 15 26 30 29 43 48]] [:append 19904 59]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 19953, which T2 created by appending 1.
  - T2 < T3, because T3 observed T2's append of 1 to key 19953.
  - T3 < T4, because T4 observed T3's append of 51 to key 19946.
  - T4 < T5, because T4 completed at index 1371602, 0.039 seconds before the invocation of T5, at index 1371617.
  - T5 < T6, because T6 appended 59 after T5 appended 57 to 19904.
  - However, T6 < T1, because T6 completed at index 1371702, 0.008 seconds before the invocation of T1, at index 1371705: a contradiction!


G-single-item-realtime #9
Let:
  T1 = {:index 489760, :time 1047341630467, :type :ok, :process 7, :f :txn, :value [[:append 7151 4]]}
  T2 = {:index 489764, :time 1047371037748, :type :ok, :process 2, :f :txn, :value [[:append 7151 7] [:append 7151 8] [:r 7151 [4 7 8]]]}
  T3 = {:index 489770, :time 1047381604307, :type :ok, :process 8, :f :txn, :value [[:r 7151 nil]]}

Then:
  - T1 < T2, because T2 appended 7 after T1 appended 4 to 7151.
  - T2 < T3, because T2 completed at index 489764, 0.010 seconds before the invocation of T3, at index 489769.
  - However, T3 < T1, because T3 observed the initial (nil) state of 7151, which T1 created by appending 4: a contradiction!


G-single-item-realtime #10
Let:
  T1 = {:index 1077584, :time 2602801313829, :type :ok, :process 1, :f :txn, :value [[:append 15763 2]]}
  T2 = {:index 1077618, :time 2602883769352, :type :ok, :process 3, :f :txn, :value [[:r 15763 [2]] [:r 15763 [2]] [:r 15756 [2 3 5 7 9 12 14 15 24]]]}
  T3 = {:index 1077624, :time 2602917766659, :type :ok, :process 7, :f :txn, :value [[:append 15742 9]]}
  T4 = {:index 1077628, :time 2602921634796, :type :ok, :process 8, :f :txn, :value [[:r 15763 nil]]}

Then:
  - T1 < T2, because T2 observed T1's append of 2 to key 15763.
  - T2 < T3, because T2 completed at index 1077618, 0.017 seconds before the invocation of T3, at index 1077621.
  - T3 < T4, because T3 completed at index 1077624, 0.001 seconds before the invocation of T4, at index 1077627.
  - However, T4 < T1, because T4 observed the initial (nil) state of 15763, which T1 created by appending 2: a contradiction!


G-single-item-realtime #11
Let:
  T1 = {:index 742456, :time 1660376419391, :type :ok, :process 7, :f :txn, :value [[:r 10755 nil]]}
  T2 = {:index 737792, :time 1648460945089, :type :ok, :process 2, :f :txn, :value [[:r 10760 [1 2 6 7 8 14 17]] [:r 10763 nil] [:append 10755 4] [:append 10740 79]]}
  T3 = {:index 738278, :time 1649614565853, :type :ok, :process 7, :f :txn, :value [[:append 10755 5]]}
  T4 = {:index 738488, :time 1650137562244, :type :ok, :process 2, :f :txn, :value [[:append 10778 25] [:append 10755 7]]}
  T5 = {:index 740034, :time 1654148784451, :type :ok, :process 8, :f :txn, :value [[:r 10740 [1 4 5 6 12 16 18 31 36 44 47 49 51 53 55 59 62 65 66 70 71 73 76 78 79 80 83 84 90 91 95 98 99 106 108 110 111 113 121 124 127 131 137]] [:append 10755 12]]}
  T6 = {:index 741414, :time 1657754787017, :type :ok, :process 14, :f :txn, :value [[:append 10825 38] [:append 10755 19] [:append 10825 39]]}
  T7 = {:index 741812, :time 1658779461164, :type :ok, :process 3, :f :txn, :value [[:r 10822 [4 7 9 11 17 18 20 24 28 32 31 37 44 45 46 47 51 52 53 55 56 59 58 66]] [:append 10755 20] [:append 10835 1]]}
  T8 = {:index 741934, :time 1659089976357, :type :ok, :process 9, :f :txn, :value [[:append 10755 21] [:append 10836 38]]}
  T9 = {:index 742212, :time 1659729761785, :type :ok, :process 0, :f :txn, :value [[:r 10836 [1 8 17 18 26 27 36 38 47 43 59 60 76 77 81 90 102 107 109 108 118 122 123 124 125 127 134 133 144 142 149]] [:append 10755 22]]}
  T10 = {:index 742326, :time 1660011675655, :type :ok, :process 9, :f :txn, :value [[:append 10755 24]]}
  T11 = {:index 742394, :time 1660234486045, :type :ok, :process 1, :f :txn, :value [[:append 10646 99] [:r 10753 [2 5 7 12 19 22 23 24 26 29 30 32 36 38]] [:r 10755 [4 5 7 12 19 20 21 22 24]] [:r 10847 nil]]}
  T12 = {:index 742448, :time 1660373728917, :type :ok, :process 3, :f :txn, :value [[:append 10646 100]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 10755, which T2 created by appending 4.
  - T2 < T3, because T3 appended 5 after T2 appended 4 to 10755.
  - T3 < T4, because T4 appended 7 after T3 appended 5 to 10755.
  - T4 < T5, because T5 appended 12 after T4 appended 7 to 10755.
  - T5 < T6, because T6 appended 19 after T5 appended 12 to 10755.
  - T6 < T7, because T7 appended 20 after T6 appended 19 to 10755.
  - T7 < T8, because T8 appended 21 after T7 appended 20 to 10755.
  - T8 < T9, because T9 appended 22 after T8 appended 21 to 10755.
  - T9 < T10, because T10 appended 24 after T9 appended 22 to 10755.
  - T10 < T11, because T11 observed T10's append of 24 to key 10755.
  - T11 < T12, because T12 appended 100 after T11 appended 99 to 10646.
  - However, T12 < T1, because T12 completed at index 742448, 0.002 seconds before the invocation of T1, at index 742455: a contradiction!


G-single-item-realtime #12
Let:
  T1 = {:index 431586, :time 914646778614, :type :ok, :process 0, :f :txn, :value [[:append 6376 2] [:r 6376 [2]] [:append 6376 3]]}
  T2 = {:index 431594, :time 914649278000, :type :ok, :process 7, :f :txn, :value [[:r 6376 nil]]}

Then:
  - T1 < T2, because T1 completed at index 431586, 0.001 seconds before the invocation of T2, at index 431593.
  - However, T2 < T1, because T2 observed the initial (nil) state of 6376, which T1 created by appending 2: a contradiction!


G-single-item-realtime #13
Let:
  T1 = {:index 442312, :time 938954445240, :type :ok, :process 8, :f :txn, :value [[:r 6498 nil]]}
  T2 = {:index 442310, :time 938954079474, :type :ok, :process 8, :f :txn, :value [[:append 6498 2]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 6498, which T2 created by appending 2.
  - However, T2 < T1, because T2 completed at index 442310, 0.000 seconds before the invocation of T1, at index 442311: a contradiction!


G-single-item-realtime #14
Let:
  T1 = {:index 1371534, :time 3577083431261, :type :ok, :process 19, :f :txn, :value [[:r 19951 [1 2 4]]]}
  T2 = {:index 1371528, :time 3577080657322, :type :ok, :process 15, :f :txn, :value [[:append 19951 5]]}

Then:
  - T1 < T2, because T1 did not observe T2's append of 5 to 19951.
  - However, T2 < T1, because T2 completed at index 1371528, 0.003 seconds before the invocation of T1, at index 1371533: a contradiction!


G-single-item-realtime #15
Let:
  T1 = {:index 563584, :time 1220572307401, :type :ok, :process 3, :f :txn, :value [[:r 8223 nil]]}
  T2 = {:index 563548, :time 1220438603297, :type :ok, :process 4, :f :txn, :value [[:r 8223 nil] [:r 8223 nil] [:r 8223 nil] [:append 8223 1]]}
  T3 = {:index 563566, :time 1220492324514, :type :ok, :process 8, :f :txn, :value [[:r 8219 [5 6 13 27]] [:r 8223 [1]] [:append 8223 10]]}
  T4 = {:index 563580, :time 1220571703486, :type :ok, :process 7, :f :txn, :value [[:r 8219 [5 6 13 27]]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 8223, which T2 created by appending 1.
  - T2 < T3, because T3 appended 10 after T2 appended 1 to 8223.
  - T3 < T4, because T3 completed at index 563566, 0.075 seconds before the invocation of T4, at index 563579.
  - However, T4 < T1, because T4 completed at index 563580, 0.000 seconds before the invocation of T1, at index 563583: a contradiction!


G-single-item-realtime #16
Let:
  T1 = {:index 675717, :time 1491941446163, :type :ok, :process 8, :f :txn, :value [[:r 9832 nil]]}
  T2 = {:index 675674, :time 1491829016731, :type :ok, :process 1, :f :txn, :value [[:append 9832 11]]}
  T3 = {:index 675682, :time 1491862925436, :type :ok, :process 3, :f :txn, :value [[:append 9832 15] [:r 9832 [11 15]]]}
  T4 = {:index 675700, :time 1491900924582, :type :ok, :process 8, :f :txn, :value [[:r 9832 [11 15]] [:r 9832 [11 15]] [:append 9806 77]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 9832, which T2 created by appending 11.
  - T2 < T3, because T3 appended 15 after T2 appended 11 to 9832.
  - T3 < T4, because T4 observed T3's append of 15 to key 9832.
  - However, T4 < T1, because T4 completed at index 675700, 0.000 seconds before the invocation of T1, at index 675701: a contradiction!


G-single-item-realtime #17
Let:
  T1 = {:index 429448, :time 909617117433, :type :ok, :process 4, :f :txn, :value [[:r 6341 nil]]}
  T2 = {:index 429402, :time 909535357183, :type :ok, :process 4, :f :txn, :value [[:append 6341 2] [:r 6341 [2]] [:r 6329 [2 4 5 6 7 10 18]]]}
  T3 = {:index 429406, :time 909542535858, :type :ok, :process 4, :f :txn, :value [[:append 6341 3] [:append 6341 4]]}
  T4 = {:index 429446, :time 909614445580, :type :ok, :process 4, :f :txn, :value [[:r 6340 [5 7 14 15 18 23]] [:append 6340 24] [:r 6340 [5 7 14 15 18 23 24]] [:append 6340 25]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 6341, which T2 created by appending 2.
  - T2 < T3, because T3 appended 3 after T2 appended 2 to 6341.
  - T3 < T4, because T3 completed at index 429406, 0.000 seconds before the invocation of T4, at index 429407.
  - However, T4 < T1, because T4 completed at index 429446, 0.000 seconds before the invocation of T1, at index 429447: a contradiction!


G-single-item-realtime #18
Let:
  T1 = {:index 431992, :time 915558341577, :type :ok, :process 4, :f :txn, :value [[:append 6380 1] [:r 6380 [1]] [:r 6380 [1]]]}
  T2 = {:index 432002, :time 915576988483, :type :ok, :process 3, :f :txn, :value [[:append 6380 2]]}
  T3 = {:index 432036, :time 915679041426, :type :ok, :process 3, :f :txn, :value [[:append 6354 84] [:append 6374 9] [:append 6380 12]]}
  T4 = {:index 432092, :time 915834188515, :type :ok, :process 0, :f :txn, :value [[:r 6380 [1 2 12 17 25]] [:r 6380 [1 2 12 17 25]] [:r 6380 [1 2 12 17 25]] [:r 6370 [4 6 10 11 17 25 20 30 31 32 42 46 47 55 57 60 61 63]]]}
  T5 = {:index 432106, :time 915853967242, :type :ok, :process 4, :f :txn, :value [[:r 6380 [1 2 12 17 25 28 29]] [:r 6380 [1 2 12 17 25 28 29]]]}
  T6 = {:index 432128, :time 915897783945, :type :ok, :process 9, :f :txn, :value [[:r 6380 [1 2 12 17 25 28 29 36 35]] [:r 6370 [4 6 10 11 17 25 20 30 31 32 42 46 47 55 57 60 61 63 70]] [:r 6374 [4 5 7 9]]]}
  T7 = {:index 432138, :time 915906061761, :type :ok, :process 9, :f :txn, :value [[:r 6380 nil]]}

Then:
  - T1 < T2, because T2 appended 2 after T1 appended 1 to 6380.
  - T2 < T3, because T3 appended 12 after T2 appended 2 to 6380.
  - T3 < T4, because T3 completed at index 432036, 0.018 seconds before the invocation of T4, at index 432043.
  - T4 < T5, because T4 completed at index 432092, 0.010 seconds before the invocation of T5, at index 432099.
  - T5 < T6, because T5 completed at index 432106, 0.016 seconds before the invocation of T6, at index 432117.
  - T6 < T7, because T6 completed at index 432128, 0.000 seconds before the invocation of T7, at index 432129.
  - However, T7 < T1, because T7 observed the initial (nil) state of 6380, which T1 created by appending 1: a contradiction!


G-single-item-realtime #19
Let:
  T1 = {:index 936458, :time 2184243325827, :type :ok, :process 8, :f :txn, :value [[:r 13753 nil]]}
  T2 = {:index 936410, :time 2184110494473, :type :ok, :process 9, :f :txn, :value [[:append 13753 8]]}
  T3 = {:index 936432, :time 2184169517240, :type :ok, :process 2, :f :txn, :value [[:append 13733 117] [:append 13753 20] [:append 13753 21]]}
  T4 = {:index 936456, :time 2184243044949, :type :ok, :process 8, :f :txn, :value [[:append 13733 118] [:r 13753 [8 20 21 13 14]] [:append 13743 147] [:r 13753 [8 20 21 13 14]]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 13753, which T2 created by appending 8.
  - T2 < T3, because T3 appended 20 after T2 appended 8 to 13753.
  - T3 < T4, because T4 appended 118 after T3 appended 117 to 13733.
  - However, T4 < T1, because T4 completed at index 936456, 0.000 seconds before the invocation of T1, at index 936457: a contradiction!


G-single-item-realtime #20
Let:
  T1 = {:index 66940, :time 137155402103, :type :ok, :process 1, :f :txn, :value [[:r 937 nil]]}
  T2 = {:index 66854, :time 137004404064, :type :ok, :process 5, :f :txn, :value [[:append 937 1] [:append 856 110]]}
  T3 = {:index 66880, :time 137065729101, :type :ok, :process 4, :f :txn, :value [[:r 856 [2 8 14 12 13 15 18 28 32 35 39 42 40 44 45 53 56 57 60 62 64 65 66 70 72 73 75 80 83 85 86 89 91 95 98 100 102 104 107 110]]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 937, which T2 created by appending 1.
  - T2 < T3, because T3 observed T2's append of 110 to key 856.
  - However, T3 < T1, because T3 completed at index 66880, 0.015 seconds before the invocation of T1, at index 66891: a contradiction!


G-single-item-realtime #21
Let:
  T1 = {:index 437906, :time 928704466311, :type :ok, :process 4, :f :txn, :value [[:r 6435 nil]]}
  T2 = {:index 437680, :time 928255001747, :type :ok, :process 1, :f :txn, :value [[:r 6435 nil] [:append 6435 2]]}
  T3 = {:index 437692, :time 928277516207, :type :ok, :process 1, :f :txn, :value [[:r 6435 [2]] [:r 6435 [2]]]}
  T4 = {:index 437696, :time 928279993029, :type :ok, :process 9, :f :txn, :value [[:append 6436 2]]}
  T5 = {:index 437724, :time 928377841381, :type :ok, :process 5, :f :txn, :value [[:append 6435 13] [:append 6408 86] [:append 6436 3]]}
  T6 = {:index 437860, :time 928647820269, :type :ok, :process 1, :f :txn, :value [[:append 6437 1] [:append 6438 5] [:append 6408 92]]}
  T7 = {:index 437892, :time 928688394378, :type :ok, :process 2, :f :txn, :value [[:append 5901 224] [:r 6437 [2 1]]]}
  T8 = {:index 437896, :time 928693687787, :type :ok, :process 0, :f :txn, :value [[:append 6435 78] [:append 6435 79]]}
  T9 = {:index 437902, :time 928699998750, :type :ok, :process 4, :f :txn, :value [[:append 6435 80] [:append 6435 81]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 6435, which T2 created by appending 2.
  - T2 < T3, because T3 observed T2's append of 2 to key 6435.
  - T3 < T4, because T3 completed at index 437692, 0.001 seconds before the invocation of T4, at index 437695.
  - T4 < T5, because T5 appended 3 after T4 appended 2 to 6436.
  - T5 < T6, because T6 appended 92 after T5 appended 86 to 6408.
  - T6 < T7, because T7 observed T6's append of 1 to key 6437.
  - T7 < T8, because T7 completed at index 437892, 0.000 seconds before the invocation of T8, at index 437895.
  - T8 < T9, because T9 appended 80 after T8 appended 79 to 6435.
  - However, T9 < T1, because T9 completed at index 437902, 0.000 seconds before the invocation of T1, at index 437903: a contradiction!


G-single-item-realtime #22
Let:
  T1 = {:index 784810, :time 1770264412287, :type :ok, :process 7, :f :txn, :value [[:r 11495 nil]]}
  T2 = {:index 784750, :time 1770083670727, :type :ok, :process 0, :f :txn, :value [[:append 11495 2] [:append 11416 56]]}
  T3 = {:index 784756, :time 1770094782338, :type :ok, :process 0, :f :txn, :value [[:append 11494 44]]}
  T4 = {:index 784764, :time 1770163715367, :type :ok, :process 0, :f :txn, :value [[:r 11494 [2 3 15 25 36 43 44]] [:r 11424 [1 3 7 8 9 14 16 23]] [:append 11494 47] [:r 11494 [2 3 15 25 36 43 44 47]]]}
  T5 = {:index 784782, :time 1770205077486, :type :ok, :process 14, :f :txn, :value [[:append 11494 57]]}
  T6 = {:index 784806, :time 1770257789545, :type :ok, :process 9, :f :txn, :value [[:append 11476 32] [:append 11464 185]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 11495, which T2 created by appending 2.
  - T2 < T3, because T2 completed at index 784750, 0.000 seconds before the invocation of T3, at index 784751.
  - T3 < T4, because T4 appended 47 after T3 appended 44 to 11494.
  - T4 < T5, because T5 appended 57 after T4 appended 47 to 11494.
  - T5 < T6, because T5 completed at index 784782, 0.046 seconds before the invocation of T6, at index 784795.
  - However, T6 < T1, because T6 completed at index 784806, 0.006 seconds before the invocation of T1, at index 784809: a contradiction!


G-single-item-realtime #23
Let:
  T1 = {:index 1372142, :time 3579259286083, :type :ok, :process 1, :f :txn, :value [[:r 19960 nil]]}
  T2 = {:index 1372118, :time 3579134010702, :type :ok, :process 2, :f :txn, :value [[:append 19960 1] [:r 19960 [1]]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 19960, which T2 created by appending 1.
  - However, T2 < T1, because T2 completed at index 1372118, 0.029 seconds before the invocation of T1, at index 1372127: a contradiction!


G-single-item-realtime #24
Let:
  T1 = {:index 431438, :time 914333006708, :type :ok, :process 0, :f :txn, :value [[:r 6365 nil]]}
  T2 = {:index 431416, :time 914292814542, :type :ok, :process 6, :f :txn, :value [[:r 6365 nil] [:r 6365 nil] [:append 6365 1]]}
  T3 = {:index 431432, :time 914315445221, :type :ok, :process 9, :f :txn, :value [[:append 6258 80] [:r 6365 [1 4]] [:r 6365 [1 4]]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 6365, which T2 created by appending 1.
  - T2 < T3, because T2 completed at index 431416, 0.015 seconds before the invocation of T3, at index 431425.
  - However, T3 < T1, because T3 completed at index 431432, 0.011 seconds before the invocation of T1, at index 431437: a contradiction!


G-single-item-realtime #25
Let:
  T1 = {:index 785322, :time 1771516570943, :type :ok, :process 14, :f :txn, :value [[:r 11503 nil]]}
  T2 = {:index 785316, :time 1771513812182, :type :ok, :process 0, :f :txn, :value [[:r 11502 [2 12 17]] [:append 11503 1]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 11503, which T2 created by appending 1.
  - However, T2 < T1, because T2 completed at index 785316, 0.002 seconds before the invocation of T1, at index 785321: a contradiction!


G-single-item-realtime #26
Let:
  T1 = {:index 795732, :time 1798520801722, :type :ok, :process 9, :f :txn, :value [[:r 11670 nil]]}
  T2 = {:index 795714, :time 1798489816425, :type :ok, :process 2, :f :txn, :value [[:append 11670 3]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 11670, which T2 created by appending 3.
  - However, T2 < T1, because T2 completed at index 795714, 0.026 seconds before the invocation of T1, at index 795727: a contradiction!


G-single-item-realtime #27
Let:
  T1 = {:index 440320, :time 934273774664, :type :ok, :process 5, :f :txn, :value [[:r 6461 nil]]}
  T2 = {:index 440314, :time 934269545832, :type :ok, :process 8, :f :txn, :value [[:r 6444 [3 4 8 11 14 16 18 19 20 23 31 32 33 37]] [:append 6461 1]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 6461, which T2 created by appending 1.
  - However, T2 < T1, because T2 completed at index 440314, 0.002 seconds before the invocation of T1, at index 440317: a contradiction!


G-single-item-realtime #28
Let:
  T1 = {:index 1354590, :time 3516300311014, :type :ok, :process 6, :f :txn, :value [[:append 19739 11] [:r 19736 [1 6 9 15 18 19 20 30 32 36 42]] [:append 19739 12]]}
  T2 = {:index 1354608, :time 3516352184004, :type :ok, :process 0, :f :txn, :value [[:r 19739 nil]]}
  T3 = {:index 1354610, :time 3516352530992, :type :ok, :process 0, :f :txn, :value [[:r 19739 nil]]}
  T4 = {:index 1354568, :time 3516217364072, :type :ok, :process 6, :f :txn, :value [[:append 19573 130] [:append 19739 7]]}

Then:
  - T1 < T2, because T1 completed at index 1354590, 0.024 seconds before the invocation of T2, at index 1354601.
  - T2 < T3, because T2 completed at index 1354608, 0.000 seconds before the invocation of T3, at index 1354609.
  - T3 < T4, because T3 observed the initial (nil) state of 19739, which T4 created by appending 7.
  - However, T4 < T1, because T1 appended 11 after T4 appended 7 to 19739: a contradiction!


G-single-item-realtime #29
Let:
  T1 = {:index 20898, :time 43374387754, :type :ok, :process 0, :f :txn, :value [[:append 270 128] [:r 307 [1]]]}
  T2 = {:index 20964, :time 43498568867, :type :ok, :process 5, :f :txn, :value [[:r 306 [1 2 19 17 18 24 26 35 36 39 43 44 45 51 52 53 54 58 60 57 63]] [:r 307 [1 8 9 16 17]] [:r 270 [2 4 7 10 11 12 13 18 21 26 27 29 33 37 40 41 43 44 46 47 48 54 57 62 65 67 70 77 78 80 88 90 91 94 95 96 102 104 105 108 110 111 113 114 119 123 128]] [:r 307 [1 8 9 16 17]]]}
  T3 = {:index 21010, :time 43590211395, :type :ok, :process 5, :f :txn, :value [[:append 307 31]]}
  T4 = {:index 21024, :time 43618593770, :type :ok, :process 5, :f :txn, :value [[:append 306 73] [:append 306 74] [:append 307 43] [:append 270 134]]}
  T5 = {:index 21050, :time 43673850183, :type :ok, :process 7, :f :txn, :value [[:r 306 [1 2 19 17 18 24 26 35 36 39 43 44 45 51 52 53 54 58 60 57 63 65 73 74]] [:append 306 77]]}
  T6 = {:index 21058, :time 43693472224, :type :ok, :process 1, :f :txn, :value [[:append 307 54] [:r 307 [1 8 9 16 17 13 21 33 36 40 31 43 49 54]] [:r 307 [1 8 9 16 17 13 21 33 36 40 31 43 49 54]] [:append 307 55]]}
  T7 = {:index 21074, :time 43724566902, :type :ok, :process 6, :f :txn, :value [[:append 307 59] [:r 307 [1 8 9 16 17 13 21 33 36 40 31 43 49 54 55 59]]]}
  T8 = {:index 21086, :time 43739688300, :type :ok, :process 3, :f :txn, :value [[:r 307 [1 8 9 16 17 13 21 33 36 40 31 43 49 54 55 59]] [:r 307 [1 8 9 16 17 13 21 33 36 40 31 43 49 54 55 59]]]}
  T9 = {:index 21090, :time 43757638201, :type :ok, :process 4, :f :txn, :value [[:append 128 175]]}
  T10 = {:index 21120, :time 43827770713, :type :ok, :process 0, :f :txn, :value [[:r 307 [1 8 9 16 17 13 21 33 36 40 31 43 49 54 55 59 56 57]] [:r 6 [5 8 9 10 12 13 20 22 24 35 37 38 39 43 46 51 52 53 56 58 61 68 80 82 88 89 90 91 93 95 96 97 98 104 105 108 111 113 117 119 127 128 130 134 136 138 141 144 145 146 151 154 156 163 166 167 168 174 177 178 181 182]] [:r 307 [1 8 9 16 17 13 21 33 36 40 31 43 49 54 55 59 56 57]]]}
  T11 = {:index 21122, :time 43828155809, :type :ok, :process 0, :f :txn, :value [[:r 307 nil]]}
  T12 = {:index 20872, :time 43336684778, :type :ok, :process 6, :f :txn, :value [[:r 307 nil] [:append 307 1] [:r 307 [1]] [:r 307 [1]]]}

Then:
  - T1 < T2, because T2 observed T1's append of 128 to key 270.
  - T2 < T3, because T2 completed at index 20964, 0.000 seconds before the invocation of T3, at index 20965.
  - T3 < T4, because T4 appended 43 after T3 appended 31 to 307.
  - T4 < T5, because T5 appended 77 after T4 appended 74 to 306.
  - T5 < T6, because T5 completed at index 21050, 0.015 seconds before the invocation of T6, at index 21057.
  - T6 < T7, because T7 appended 59 after T6 appended 55 to 307.
  - T7 < T8, because T8 observed T7's append of 59 to key 307.
  - T8 < T9, because T8 completed at index 21086, 0.008 seconds before the invocation of T9, at index 21089.
  - T9 < T10, because T9 completed at index 21090, 0.014 seconds before the invocation of T10, at index 21099.
  - T10 < T11, because T10 completed at index 21120, 0.000 seconds before the invocation of T11, at index 21121.
  - T11 < T12, because T11 observed the initial (nil) state of 307, which T12 created by appending 1.
  - However, T12 < T1, because T1 observed T12's append of 1 to key 307: a contradiction!


G-single-item-realtime #30
Let:
  T1 = {:index 785338, :time 1771550345145, :type :ok, :process 9, :f :txn, :value [[:r 11502 nil]]}
  T2 = {:index 785276, :time 1771379790855, :type :ok, :process 7, :f :txn, :value [[:r 11502 nil] [:append 11502 2] [:r 11502 [2]]]}
  T3 = {:index 785294, :time 1771437880228, :type :ok, :process 5, :f :txn, :value [[:append 11502 12]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 11502, which T2 created by appending 2.
  - T2 < T3, because T3 appended 12 after T2 appended 2 to 11502.
  - However, T3 < T1, because T3 completed at index 785294, 0.020 seconds before the invocation of T1, at index 785307: a contradiction!