G-single-item-realtime #0
Let:
  T1 = {:index 7694, :time 86680688795, :type :ok, :process 26, :f :txn, :value [[:r 129 nil]]}
  T2 = {:index 7400, :time 85165627691, :type :ok, :process 26, :f :txn, :value [[:append 129 1] [:append 63 142] [:append 129 2]]}
  T3 = {:index 7434, :time 85312802098, :type :ok, :process 43, :f :txn, :value [[:append 63 145] [:r 84 [1 5 7 9 16 22 25 26 28 29 30 36 37 39 40 44 45 48 49 50 51 54 58]] [:append 128 7]]}
  T4 = {:index 7522, :time 85809012552, :type :ok, :process 43, :f :txn, :value [[:append 131 1] [:r 63 [2 7 6 10 11 14 19 24 25 26 28 31 32 34 36 37 40 42 45 46 48 49 50 51 53 54 56 57 61 63 64 66 67 68 69 72 73 75 76 77 81 83 84 86 88 90 92 94 97 98 99 101 103 104 107 114 115 116 118 121 122 123 124 127 128 130 135 141 142 145]]]}
  T5 = {:index 7560, :time 86003765072, :type :ok, :process 26, :f :txn, :value [[:r 131 [1]] [:append 134 3] [:append 131 3]]}
  T6 = {:index 7606, :time 86286329861, :type :ok, :process 38, :f :txn, :value [[:append 131 6]]}
  T7 = {:index 7610, :time 86297324979, :type :ok, :process 38, :f :txn, :value [[:r 131 [1 3 6]] [:append 131 8]]}
  T8 = {:index 7618, :time 86326085790, :type :ok, :process 38, :f :txn, :value [[:append 135 1] [:append 131 9]]}
  T9 = {:index 7676, :time 86630006645, :type :ok, :process 26, :f :txn, :value [[:r 131 [1 3 6 8 9]] [:append 129 76] [:r 129 [1 2 5 6 8 9 13 18 20 21 22 24 25 30 34 35 36 37 42 44 45 50 51 53 60 61 65 68 69 73 74 75 76]]]}
  T10 = {:index 7690, :time 86672217088, :type :ok, :process 26, :f :txn, :value [[:append 129 80]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 129, which T2 created by appending 1.
  - T2 < T3, because T3 appended 145 after T2 appended 142 to 63.
  - T3 < T4, because T4 observed T3's append of 145 to key 63.
  - T4 < T5, because T5 appended 3 after T4 appended 1 to 131.
  - T5 < T6, because T6 appended 6 after T5 appended 3 to 131.
  - T6 < T7, because T7 appended 8 after T6 appended 6 to 131.
  - T7 < T8, because T8 appended 9 after T7 appended 8 to 131.
  - T8 < T9, because T9 observed T8's append of 9 to key 131.
  - T9 < T10, because T10 appended 80 after T9 appended 76 to 129.
  - However, T10 < T1, because T10 completed at index 7690, 0.000 seconds before the invocation of T1, at index 7691: a contradiction!


G-single-item-realtime #1
Let:
  T1 = {:index 242370, :time 288516418829, :type :ok, :process 49, :f :txn, :value [[:r 3708 [1 3 4 9 10 12 14 18 23 26 29 30 33 36 34 39 43 45 48]]]}
  T2 = {:index 242366, :time 288411858449, :type :ok, :process 49, :f :txn, :value [[:r 3708 [1 3 4 9 10 12 14 18 23 26 29 30 33 36 34 39 43 45 48]] [:append 3708 52]]}
  T3 = {:index 242368, :time 288472403767, :type :ok, :process 49, :f :txn, :value [[:r 3706 [1 2 4 5 6 12 17 18 22 25 33 36 39 40 43 44 52 53 55 62 63 65 68 78 79 85 86 98 97 103 104 106 122 128]] [:r 3706 [1 2 4 5 6 12 17 18 22 25 33 36 39 40 43 44 52 53 55 62 63 65 68 78 79 85 86 98 97 103 104 106 122 128]] [:append 3708 53]]}

Then:
  - T1 < T2, because T1 did not observe T2's append of 52 to 3708.
  - T2 < T3, because T3 appended 53 after T2 appended 52 to 3708.
  - However, T3 < T1, because T3 completed at index 242368, 0.000 seconds before the invocation of T1, at index 242369: a contradiction!


G-single-item-realtime #2
Let:
  T1 = {:index 1434, :time 4502391711, :type :ok, :process 16, :f :txn, :value [[:r 28 nil]]}
  T2 = {:index 1396, :time 4408417065, :type :ok, :process 17, :f :txn, :value [[:append 28 1]]}
  T3 = {:index 1402, :time 4416806843, :type :ok, :process 16, :f :txn, :value [[:append 28 4] [:append 28 5]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 28, which T2 created by appending 1.
  - T2 < T3, because T3 appended 4 after T2 appended 1 to 28.
  - However, T3 < T1, because T3 completed at index 1402, 0.000 seconds before the invocation of T1, at index 1403: a contradiction!


G-single-item-realtime #3
Let:
  T1 = {:index 226198, :time 167619056085, :type :ok, :process 39, :f :txn, :value [[:r 3470 nil]]}
  T2 = {:index 226190, :time 167372231549, :type :ok, :process 39, :f :txn, :value [[:r 3466 [37]] [:append 3207 92] [:append 3470 1]]}
  T3 = {:index 226196, :time 167561219300, :type :ok, :process 39, :f :txn, :value [[:append 3458 148] [:append 3470 2] [:append 3458 149]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 3470, which T2 created by appending 1.
  - T2 < T3, because T3 appended 2 after T2 appended 1 to 3470.
  - However, T3 < T1, because T3 completed at index 226196, 0.000 seconds before the invocation of T1, at index 226197: a contradiction!


G-single-item-realtime #4
Let:
  T1 = {:index 4748, :time 11436962729, :type :ok, :process 9, :f :txn, :value [[:r 88 nil]]}
  T2 = {:index 4612, :time 11177815825, :type :ok, :process 12, :f :txn, :value [[:append 88 1]]}
  T3 = {:index 4742, :time 11420360397, :type :ok, :process 17, :f :txn, :value [[:r 88 [1]] [:append 63 42] [:append 90 31] [:append 88 17]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 88, which T2 created by appending 1.
  - T2 < T3, because T3 appended 17 after T2 appended 1 to 88.
  - However, T3 < T1, because T3 completed at index 4742, 0.012 seconds before the invocation of T1, at index 4747: a contradiction!