G-single-item-realtime #0
Let:
  T1 = {:index 214242, :time 143817358592, :type :ok, :process 32, :f :txn, :value [[:r 3188 nil]]}
  T2 = {:index 213958, :time 141820020937, :type :ok, :process 29, :f :txn, :value [[:append 3182 20] [:append 3188 1] [:r 3187 [1]] [:append 3188 2]]}
  T3 = {:index 213962, :time 141839528579, :type :ok, :process 29, :f :txn, :value [[:append 3019 210] [:r 3188 [1 2]] [:r 3182 [5 7 9 10 11 12 13 14 15 16 18 20]]]}
  T4 = {:index 214162, :time 143264659363, :type :ok, :process 32, :f :txn, :value [[:append 3145 92] [:append 3019 212]]}
  T5 = {:index 214226, :time 143676815939, :type :ok, :process 24, :f :txn, :value [[:append 2729 80] [:r 3145 [71 73 76 78 80 81 82 83 85 89 90 92]]]}
  T6 = {:index 214236, :time 143774801091, :type :ok, :process 24, :f :txn, :value [[:append 3182 56] [:r 3182 [5 7 9 10 11 12 13 14 15 16 18 20 21 29 30 32 33 34 36 38 37 40 39 43 44 47 48 52 53 54 56]] [:append 3182 57] [:r 3188 [1 2 3 5 6 7 8 13 14 15 16 24 25 26 27 28 30 29 34 38 45 46 43 48 49 55 56 50 59 60 61 62 63 64 65 66 68 70 72 74 79 80 84 86 87 90 92]]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 3188, which T2 created by appending 1.
  - T2 < T3, because T3 observed T2's append of 2 to key 3188.
  - T3 < T4, because T4 appended 212 after T3 appended 210 to 3019.
  - T4 < T5, because T5 observed T4's append of 92 to key 3145.
  - T5 < T6, because T5 completed at index 214226, 0.000 seconds before the invocation of T6, at index 214227.
  - However, T6 < T1, because T6 completed at index 214236, 0.042 seconds before the invocation of T1, at index 214241: a contradiction!


G-single-item-realtime #1
Let:
  T1 = {:index 146581, :time 134799418866, :type :ok, :process 22, :f :txn, :value [[:r 2194 nil]]}
  T2 = {:index 146578, :time 134791354653, :type :ok, :process 22, :f :txn, :value [[:r 2193 [11 12]] [:r 2193 [11 12]] [:append 2194 43] [:append 2194 44]]}

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


G-single-item-realtime #2
Let:
  T1 = {:index 274883, :time 222749355802, :type :ok, :process 33, :f :txn, :value [[:append 4100 93] [:append 4039 179] [:r 4103 [12 14 15 19]] [:append 4100 94]]}
  T2 = {:index 274893, :time 222761388134, :type :ok, :process 21, :f :txn, :value [[:append 4039 180]]}
  T3 = {:index 274770, :time 200660569024, :type :ok, :process 25, :f :txn, :value [[:append 4039 176] [:append 4103 3]]}
  T4 = {:index 274774, :time 200685510406, :type :ok, :process 25, :f :txn, :value [[:append 4103 4] [:r 4039 [168 169 170 171 172 173 174 175 176]]]}
  T5 = {:index 274776, :time 200776803808, :type :ok, :process 25, :f :txn, :value [[:append 4103 5] [:append 4100 65] [:append 4100 66] [:append 4039 177]]}
  T6 = {:index 274792, :time 201122681427, :type :ok, :process 25, :f :txn, :value [[:append 4100 71] [:append 4103 6]]}
  T7 = {:index 274794, :time 201200676505, :type :ok, :process 25, :f :txn, :value [[:append 4100 72] [:r 4100 [18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72]]]}
  T8 = {:index 274796, :time 201280424088, :type :ok, :process 25, :f :txn, :value [[:r 4100 [18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72]] [:append 4100 73] [:append 4103 7] [:r 4100 [18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73]]]}
  T9 = {:index 274800, :time 201479207104, :type :ok, :process 25, :f :txn, :value [[:r 4103 [1 2 3 4 5 6 7]] [:append 4100 75] [:r 4100 [18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75]] [:r 4103 [1 2 3 4 5 6 7]]]}
  T10 = {:index 274859, :time 222467456797, :type :ok, :process 21, :f :txn, :value [[:append 4103 15] [:append 4100 85]]}
  T11 = {:index 274863, :time 222566039144, :type :ok, :process 37, :f :txn, :value [[:r 4103 [12 14 15]] [:append 4095 54]]}
  T12 = {:index 274871, :time 222588211907, :type :ok, :process 37, :f :txn, :value [[:append 4100 88] [:append 4100 89] [:r 4100 [18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 77 79 80 83 84 85 88 89]]]}
  T13 = {:index 274876, :time 222716755994, :type :ok, :process 37, :f :txn, :value [[:append 4100 91] [:append 4103 19] [:append 4100 92]]}

Then:
  - T1 < T2, because T2 appended 180 after T1 appended 179 to 4039.
  - T2 < T3, because T3 appended 176 after T2 appended 180 to 4039.
  - T3 < T4, because T4 appended 4 after T3 appended 3 to 4103.
  - T4 < T5, because T5 appended 5 after T4 appended 4 to 4103.
  - T5 < T6, because T6 appended 6 after T5 appended 5 to 4103.
  - T6 < T7, because T7 appended 72 after T6 appended 71 to 4100.
  - T7 < T8, because T8 appended 73 after T7 appended 72 to 4100.
  - T8 < T9, because T9 observed T8's append of 7 to key 4103.
  - T9 < T10, because T9 did not observe T10's append of 15 to 4103.
  - T10 < T11, because T11 observed T10's append of 15 to key 4103.
  - T11 < T12, because T11 completed at index 274863, 0.001 seconds before the invocation of T12, at index 274868.
  - T12 < T13, because T12 completed at index 274871, 0.000 seconds before the invocation of T13, at index 274872.
  - However, T13 < T1, because T1 observed T13's append of 19 to key 4103: a contradiction!


G-single-item-realtime #3
Let:
  T1 = {:index 2210, :time 6161509163, :type :ok, :process 8, :f :txn, :value [[:r 59 nil]]}
  T2 = {:index 1922, :time 5593152980, :type :ok, :process 0, :f :txn, :value [[:append 59 4]]}
  T3 = {:index 1972, :time 5694427716, :type :ok, :process 7, :f :txn, :value [[:r 57 [3 5 8 11 12 4 18 27 29 30 31 34 42 54 58 61 62 69 73]] [:r 59 [4]]]}
  T4 = {:index 2010, :time 5755148053, :type :ok, :process 7, :f :txn, :value [[:r 59 [4 7 2 9 6 20 23]] [:r 59 [4 7 2 9 6 20 23]]]}
  T5 = {:index 2030, :time 5796062530, :type :ok, :process 9, :f :txn, :value [[:r 57 [3 5 8 11 12 4 18 27 29 30 31 34 42 54 58 61 62 69 73 79 80 83 84]] [:r 59 [4 7 2 9 6 20 23]] [:append 57 89]]}
  T6 = {:index 2040, :time 5805091636, :type :ok, :process 3, :f :txn, :value [[:append 5 38] [:r 59 [4 7 2 9 6 20 23]] [:r 59 [4 7 2 9 6 20 23]]]}
  T7 = {:index 2172, :time 6056520844, :type :ok, :process 6, :f :txn, :value [[:append 5 40]]}
  T8 = {:index 2174, :time 6056812266, :type :ok, :process 6, :f :txn, :value [[:r 59 nil]]}
  T9 = {:index 2202, :time 6137748798, :type :ok, :process 6, :f :txn, :value [[:r 57 [3 5 8 11 12 4 18 27 29 30 31 34 42 54 58 61 62 69 73 79 80 83 84 89 91 96 92 107 103 110 111 112 108]] [:r 59 [4 7 2 9 6 20 23 35 38 41 34 50 48 54 62 57 58 59 63]]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 59, which T2 created by appending 4.
  - T2 < T3, because T3 observed T2's append of 4 to key 59.
  - T3 < T4, because T3 completed at index 1972, 0.003 seconds before the invocation of T4, at index 1977.
  - T4 < T5, because T4 completed at index 2010, 0.013 seconds before the invocation of T5, at index 2017.
  - T5 < T6, because T5 completed at index 2030, 0.003 seconds before the invocation of T6, at index 2035.
  - T6 < T7, because T7 appended 40 after T6 appended 38 to 5.
  - T7 < T8, because T7 completed at index 2172, 0.000 seconds before the invocation of T8, at index 2173.
  - T8 < T9, because T8 completed at index 2174, 0.000 seconds before the invocation of T9, at index 2175.
  - However, T9 < T1, because T9 completed at index 2202, 0.023 seconds before the invocation of T1, at index 2209: a contradiction!