G-single-item #0
Let:
  T1 = {:index 13852, :time 28914293031, :type :ok, :process 706, :f :txn, :value [[:r 531 nil] [:append 531 3]]}
  T2 = {:index 13844, :time 28889681266, :type :ok, :process 505, :f :txn, :value [[:append 531 6]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 531, which T2 created by appending 6.
  - However, T2 < T1, because T1 appended 3 after T2 appended 6 to 531: a contradiction!


G-single-item #1
Let:
  T1 = {:index 6054, :time 13297347046, :type :ok, :process 238, :f :txn, :value [[:r 234 [1]] [:r 234 [1]] [:r 233 [2]]]}
  T2 = {:index 6048, :time 13287150147, :type :ok, :process 220, :f :txn, :value [[:r 230 [3]] [:append 228 11] [:r 233 nil] [:append 233 1]]}
  T3 = {:index 6034, :time 13258014891, :type :ok, :process 329, :f :txn, :value [[:append 233 2] [:append 234 1] [:append 228 13]]}

Then:
  - T1 < T2, because T1 did not observe T2's append of 1 to 233.
  - T2 < T3, because T3 appended 13 after T2 appended 11 to 228.
  - However, T3 < T1, because T1 observed T3's append of 1 to key 234: a contradiction!


G-single-item #2
Let:
  T1 = {:index 27388, :time 55127082252, :type :ok, :process 1105, :f :txn, :value [[:r 1040 [3]] [:r 1040 nil] [:r 1020 nil]]}
  T2 = {:index 27310, :time 54955869563, :type :ok, :process 1264, :f :txn, :value [[:append 1039 15] [:append 1040 3]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 1040, which T2 created by appending 3.
  - However, T2 < T1, because T1 observed T2's append of 3 to key 1040: a contradiction!


G-single-item #3
Let:
  T1 = {:index 2814, :time 6945607502, :type :ok, :process 113, :f :txn, :value [[:r 104 [1 3 9 10]] [:r 108 [2]]]}
  T2 = {:index 2758, :time 6868117245, :type :ok, :process 113, :f :txn, :value [[:r 108 nil] [:append 108 3] [:append 104 11]]}
  T3 = {:index 2768, :time 6887016572, :type :ok, :process 132, :f :txn, :value [[:r 108 [3]] [:r 108 [3]] [:append 108 7]]}
  T4 = {:index 2776, :time 6896676577, :type :ok, :process 107, :f :txn, :value [[:r 106 [1 6]] [:append 108 2] [:r 68 [1 8 9]]]}

Then:
  - T1 < T2, because T1 did not observe T2's append of 11 to 104.
  - T2 < T3, because T3 appended 7 after T2 appended 3 to 108.
  - T3 < T4, because T4 appended 2 after T3 appended 7 to 108.
  - However, T4 < T1, because T1 observed T4's append of 2 to key 108: a contradiction!


G-single-item #4
Let:
  T1 = {:index 13972, :time 29190905739, :type :ok, :process 598, :f :txn, :value [[:r 536 nil] [:append 527 15] [:append 536 5] [:append 535 15]]}
  T2 = {:index 13984, :time 29234251824, :type :ok, :process 716, :f :txn, :value [[:append 536 1] [:append 535 8] [:r 536 [1]]]}
  T3 = {:index 14000, :time 29246053718, :type :ok, :process 632, :f :txn, :value [[:r 537 nil] [:append 536 7]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 536, which T2 created by appending 1.
  - T2 < T3, because T3 appended 7 after T2 appended 1 to 536.
  - However, T3 < T1, because T1 appended 5 after T3 appended 7 to 536: a contradiction!


G-single-item #5
Let:
  T1 = {:index 9604, :time 20186984366, :type :ok, :process 481, :f :txn, :value [[:r 367 [1]] [:append 367 15] [:r 371 [3]]]}
  T2 = {:index 9610, :time 20204375017, :type :ok, :process 429, :f :txn, :value [[:r 371 nil] [:append 367 12] [:r 367 [1 12]] [:r 361 [1]]]}

Then:
  - T1 < T2, because T1 did not observe T2's append of 12 to 367.
  - However, T2 < T1, because T1 appended 15 after T2 appended 12 to 367: a contradiction!


G-single-item #6
Let:
  T1 = {:index 10482, :time 22023240569, :type :ok, :process 398, :f :txn, :value [[:r 406 [1]] [:append 406 4] [:r 405 [1 5 8 9]] [:r 405 nil]]}
  T2 = {:index 10442, :time 21939117303, :type :ok, :process 452, :f :txn, :value [[:r 402 [2]] [:r 403 [1 2 9 15]] [:append 405 1] [:r 402 [2]]]}
  T3 = {:index 10466, :time 21978576546, :type :ok, :process 398, :f :txn, :value [[:append 405 5]]}
  T4 = {:index 10468, :time 21986528767, :type :ok, :process 398, :f :txn, :value [[:append 405 8] [:append 405 9]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 405, which T2 created by appending 1.
  - T2 < T3, because T3 appended 5 after T2 appended 1 to 405.
  - T3 < T4, because T4 appended 8 after T3 appended 5 to 405.
  - However, T4 < T1, because T1 observed T4's append of 9 to key 405: a contradiction!


G-single-item #7
Let:
  T1 = {:index 6716, :time 14649975613, :type :ok, :process 251, :f :txn, :value [[:r 259 [2]] [:append 0 7] [:r 259 nil] [:r 259 nil]]}
  T2 = {:index 6674, :time 14550712685, :type :ok, :process 343, :f :txn, :value [[:append 259 2]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 259, which T2 created by appending 2.
  - However, T2 < T1, because T1 observed T2's append of 2 to key 259: a contradiction!


G-single-item #8
Let:
  T1 = {:index 20788, :time 42437988563, :type :ok, :process 883, :f :txn, :value [[:r 790 nil] [:append 787 16] [:append 790 1] [:r 790 nil]]}
  T2 = {:index 20750, :time 42351110947, :type :ok, :process 819, :f :txn, :value [[:append 790 2] [:r 790 [2]] [:append 790 3] [:append 786 7]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 790, which T2 created by appending 2.
  - However, T2 < T1, because T1 appended 1 after T2 appended 3 to 790: a contradiction!


G-single-item #9
Let:
  T1 = {:index 3138, :time 7542488511, :type :ok, :process 209, :f :txn, :value [[:r 122 [3]] [:r 122 nil]]}
  T2 = {:index 3106, :time 7473927373, :type :ok, :process 118, :f :txn, :value [[:r 122 nil] [:append 118 11] [:append 122 3] [:r 113 [2 5 11]]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 122, which T2 created by appending 3.
  - However, T2 < T1, because T1 observed T2's append of 3 to key 122: a contradiction!


G-single-item #10
Let:
  T1 = {:index 8804, :time 18670353588, :type :ok, :process 446, :f :txn, :value [[:r 339 nil] [:r 339 nil] [:r 338 nil] [:append 338 6]]}
  T2 = {:index 8762, :time 18592651062, :type :ok, :process 402, :f :txn, :value [[:append 338 4] [:r 338 [4]] [:r 338 [4]]]}
  T3 = {:index 8798, :time 18665774951, :type :ok, :process 315, :f :txn, :value [[:append 338 11]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 338, which T2 created by appending 4.
  - T2 < T3, because T3 appended 11 after T2 appended 4 to 338.
  - However, T3 < T1, because T1 appended 6 after T3 appended 11 to 338: a contradiction!


G-single-item #11
Let:
  T1 = {:index 4270, :time 9874981548, :type :ok, :process 155, :f :txn, :value [[:r 165 nil] [:append 164 10]]}
  T2 = {:index 4280, :time 9890892659, :type :ok, :process 182, :f :txn, :value [[:append 165 1] [:append 164 6] [:append 164 7] [:append 164 8]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 165, which T2 created by appending 1.
  - However, T2 < T1, because T1 appended 10 after T2 appended 8 to 164: a contradiction!


G-single-item #12
Let:
  T1 = {:index 18736, :time 38453327399, :type :ok, :process 813, :f :txn, :value [[:append 717 2] [:append 716 8] [:r 710 nil]]}
  T2 = {:index 18646, :time 38286906185, :type :ok, :process 884, :f :txn, :value [[:append 710 2] [:r 696 [2 5 8 10 11]] [:append 714 2] [:append 711 8]]}
  T3 = {:index 18686, :time 38359168455, :type :ok, :process 797, :f :txn, :value [[:r 714 [2]] [:append 710 4] [:r 714 nil]]}
  T4 = {:index 18704, :time 38405832826, :type :ok, :process 768, :f :txn, :value [[:append 710 8] [:append 716 2] [:append 717 1] [:r 715 [3]]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 710, which T2 created by appending 2.
  - T2 < T3, because T3 appended 4 after T2 appended 2 to 710.
  - T3 < T4, because T4 appended 8 after T3 appended 4 to 710.
  - However, T4 < T1, because T1 appended 2 after T4 appended 1 to 717: a contradiction!


G-single-item #13
Let:
  T1 = {:index 15508, :time 32256901850, :type :ok, :process 826, :f :txn, :value [[:r 594 [5]] [:r 594 [5]] [:r 594 nil] [:r 594 nil]]}
  T2 = {:index 15474, :time 32192306888, :type :ok, :process 659, :f :txn, :value [[:append 594 5] [:r 594 [5]] [:r 593 nil] [:r 594 [5]]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 594, which T2 created by appending 5.
  - However, T2 < T1, because T1 observed T2's append of 5 to key 594: a contradiction!


G-single-item #14
Let:
  T1 = {:index 2312, :time 6000971912, :type :ok, :process 78, :f :txn, :value [[:r 92 [1 5]] [:r 3 [1 5 10 15]] [:r 89 nil]]}
  T2 = {:index 2238, :time 5814349807, :type :ok, :process 105, :f :txn, :value [[:append 89 1] [:r 83 nil] [:append 83 16] [:r 87 nil]]}
  T3 = {:index 2254, :time 5886568720, :type :ok, :process 139, :f :txn, :value [[:append 91 2] [:r 89 [1]] [:append 87 2] [:append 91 3]]}
  T4 = {:index 2286, :time 5965177095, :type :ok, :process 111, :f :txn, :value [[:append 92 1] [:r 87 [2]]]}
  T5 = {:index 2304, :time 5988682570, :type :ok, :process 78, :f :txn, :value [[:r 92 [1]] [:append 92 5] [:r 92 [1 5]] [:r 92 [1 5]]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 89, which T2 created by appending 1.
  - T2 < T3, because T3 observed T2's append of 1 to key 89.
  - T3 < T4, because T4 observed T3's append of 2 to key 87.
  - T4 < T5, because T5 appended 5 after T4 appended 1 to 92.
  - However, T5 < T1, because T1 observed T5's append of 5 to key 92: a contradiction!


G-single-item #15
Let:
  T1 = {:index 2868, :time 7018391193, :type :ok, :process 216, :f :txn, :value [[:r 102 [2]] [:r 111 nil] [:r 110 [2]]]}
  T2 = {:index 2808, :time 6934017037, :type :ok, :process 125, :f :txn, :value [[:append 110 2] [:append 111 1]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 111, which T2 created by appending 1.
  - However, T2 < T1, because T1 observed T2's append of 2 to key 110: a contradiction!