diff --git a/expo/features/hpsort/HPSortNewScreen.tsx b/expo/features/hpsort/HPSortNewScreen.tsx
index b0632c56..8755996f 100644
--- a/expo/features/hpsort/HPSortNewScreen.tsx
+++ b/expo/features/hpsort/HPSortNewScreen.tsx
@@ -1,25 +1,21 @@
 import { WithSafeArea } from '@hpapp/features/common';
 import { defineScreen, useScreenTitle } from '@hpapp/features/common/stack';
 import { t } from '@hpapp/system/i18n';
-import { useState } from 'react';
 
-import HPSortNewConfigForm from './internals/new/HPSortNewConfigForm';
 import HPSortNewRoundContainer from './internals/new/HPSortNewRoundContainer';
-import { HPSortNewConfig } from './internals/new/types';
 
 export type HPSortNewSceenProps = object;
 
 export default defineScreen('/hpsort/new/', function HPSortNewSceen() {
   useScreenTitle(t('New Sort'));
-  const [config, setConfig] = useState<HPSortNewConfig | null>(null);
 
   return (
     <WithSafeArea>
-      {config === null ? (
-        <HPSortNewConfigForm onSelect={(config) => setConfig(config)} />
-      ) : (
-        <HPSortNewRoundContainer config={config} />
-      )}
+      <HPSortNewRoundContainer
+        config={{
+          numMembersToSelect: 2
+        }}
+      />
     </WithSafeArea>
   );
 });
diff --git a/expo/features/hpsort/internals/new/HPSortNewConfigForm.tsx b/expo/features/hpsort/internals/new/HPSortNewConfigForm.tsx
deleted file mode 100644
index 74c268e1..00000000
--- a/expo/features/hpsort/internals/new/HPSortNewConfigForm.tsx
+++ /dev/null
@@ -1,78 +0,0 @@
-import { BetaIcon, RadioButtonGroup, Text } from '@hpapp/features/common';
-import { FontSize, IconSize, Spacing } from '@hpapp/features/common/constants';
-import { t } from '@hpapp/system/i18n';
-import { Button } from '@rneui/themed';
-import { useState } from 'react';
-import { View, StyleSheet, Dimensions } from 'react-native';
-
-import { HPSortNewConfig } from './types';
-
-export type HPSortNewConfigFormProps = {
-  onSelect: (config: HPSortNewConfig) => void;
-};
-
-export default function HPSortNewConfigForm({ onSelect }: HPSortNewConfigFormProps) {
-  const [numMembersToSelect, setNumMembersToSelect] = useState<string | null>(null);
-  return (
-    <View style={styles.container}>
-      <Text style={styles.explanation}>{[t('Choose the number of members one round shows.')].join(' ')}</Text>
-      <RadioButtonGroup
-        containerStyle={styles.radioButtonGroup}
-        values={['2', '4']}
-        labels={[
-          <Text>2</Text>,
-          <>
-            <Text>4</Text>
-            <BetaIcon size={IconSize.Medium} />
-          </>
-        ]}
-        selectedOption={numMembersToSelect?.toString()}
-        onSelect={(value) => setNumMembersToSelect(value)}
-      />
-      <View style={styles.betaExplanation}>
-        <BetaIcon size={IconSize.Medium} />
-        <Text>
-          {t(
-            "With choosing 4, it's an experiemntal sort feature, where you can complete faster but you may not sort all members."
-          )}
-        </Text>
-      </View>
-      <Button
-        style={styles.button}
-        disabled={numMembersToSelect === null}
-        title={t('Start')}
-        onPress={() => {
-          onSelect({ numMembersToSelect: parseInt(numMembersToSelect!, 10) });
-        }}
-      />
-    </View>
-  );
-}
-
-const styles = StyleSheet.create({
-  container: {
-    flex: 1,
-    justifyContent: 'center',
-    alignItems: 'center'
-  },
-  radioButtonGroup: {
-    padding: Spacing.Large
-  },
-  explanation: {
-    paddingLeft: Spacing.Large,
-    paddingRight: Spacing.Large,
-    fontSize: FontSize.Large
-  },
-  betaExplanation: {
-    flexDirection: 'row',
-    marginBottom: Spacing.XLarge,
-    paddingLeft: Spacing.XLarge,
-    paddingRight: Spacing.XLarge,
-    fontSize: FontSize.Large
-  },
-  button: {
-    width: Dimensions.get('window').width * 0.3,
-    justifyContent: 'center',
-    marginTop: Spacing.XLarge
-  }
-});
diff --git a/expo/features/hpsort/internals/new/HPSortNewRoundContainer.tsx b/expo/features/hpsort/internals/new/HPSortNewRoundContainer.tsx
index 06b6dab6..bbea699e 100644
--- a/expo/features/hpsort/internals/new/HPSortNewRoundContainer.tsx
+++ b/expo/features/hpsort/internals/new/HPSortNewRoundContainer.tsx
@@ -13,7 +13,6 @@ import HPSortNewRoundMemberSelector from './HPSortNewRoundMemberSelector';
 import { HPSortMemberNode, HPSortNewConfig, HPSortNewRoundState } from './types';
 import HPSortBase from '../sort/HPSortBase';
 import HPSortClassicMergeSort from '../sort/HPSortClassicMergeSort';
-import HPSortTopologicalSort from '../sort/HPSortTopologicalSort';
 
 export type HPSortNewRoundContainerProps = {
   config: HPSortNewConfig;
@@ -30,11 +29,7 @@ export default function HPSortNewRoundContainer({ config }: HPSortNewRoundContai
     });
     return object.shuffle([...members]).map((m) => new HPSortMemberNode(m));
   }, [members]);
-  const [sorter, setSorter] = useState<HPSortBase<HPSortMemberNode>>(
-    config.numMembersToSelect === 2
-      ? new HPSortClassicMergeSort(list)
-      : new HPSortTopologicalSort(list, config.numMembersToSelect, true)
-  );
+  const [sorter, setSorter] = useState<HPSortBase<HPSortMemberNode>>(new HPSortClassicMergeSort(list));
   const comparable = sorter.getComparable();
   const [stats, setStats] = useState<HPSortNewRoundState>({
     numCompared: 0,
@@ -50,11 +45,7 @@ export default function HPSortNewRoundContainer({ config }: HPSortNewRoundContai
             logEvent('hpsort_retry', {
               num_members_to_select: config.numMembersToSelect
             });
-            setSorter(
-              config.numMembersToSelect === 2
-                ? new HPSortClassicMergeSort(list)
-                : new HPSortTopologicalSort(list, config.numMembersToSelect)
-            );
+            setSorter(new HPSortClassicMergeSort(list));
             setStats({
               numCompared: 0,
               startTime: new Date(),
diff --git a/expo/features/hpsort/internals/sort/HPSortTopologicalSort.test.ts b/expo/features/hpsort/internals/sort/HPSortTopologicalSort.test.ts
deleted file mode 100644
index e0207f7a..00000000
--- a/expo/features/hpsort/internals/sort/HPSortTopologicalSort.test.ts
+++ /dev/null
@@ -1,124 +0,0 @@
-import HPSortTopologicalSort, { HPSortTopologicalSortNode } from './HPSortTopologicalSort';
-
-class NumberNode implements HPSortTopologicalSortNode {
-  constructor(
-    public value: number,
-    private id: number
-  ) {}
-  getId() {
-    return this.id.toString();
-  }
-  toString() {
-    return this.value.toString();
-  }
-  static fromNumber(value: number, id: number) {
-    return new NumberNode(value, id);
-  }
-}
-
-describe('HPSortTopologicalSort', () => {
-  // we use number as T to test sort functionality.
-
-  it('minimum case', () => {
-    const dataset = [4, 8].map(NumberNode.fromNumber);
-    const s = new HPSortTopologicalSort(dataset);
-    const c = s.getComparable()!;
-    expect(c[0].toString()).toEqual('4');
-    expect(c[1].toString()).toEqual('8');
-    s.select(1);
-    const next = s.getComparable();
-    expect(next).toBeNull();
-    const values = s.getResult().map((v) => v.value.value);
-    expect(values).toEqual([8, 4]);
-  });
-
-  it('sample', () => {
-    // [8,4,3,1,4] => [8,4,4,3,1]
-    const dataset = [8, 4, 3, 1, 4].map(NumberNode.fromNumber);
-    const s = new HPSortTopologicalSort(dataset);
-    let c = s.getComparable()!;
-    expect(c.map((v) => v.toString())).toEqual(['8', '4', '3', '1']);
-    s.select(0); // choose 8 at the first
-    c = s.getComparable()!;
-    expect(c.map((v) => v.toString())).toEqual(['8', '4']);
-    s.select(0); // choose 8 at the first
-    c = s.getComparable()!;
-    expect(c.map((v) => v.toString())).toEqual(['4', '3', '1', '4']);
-    s.select(0, 3); // choose 4 at the first and 4 at the last
-    c = s.getComparable()!;
-    expect(c.map((v) => v.toString())).toEqual(['4', '4']);
-    s.tie();
-    c = s.getComparable()!;
-    expect(c.map((v) => v.toString())).toEqual(['3', '1']);
-    s.select(0); // choose 3 at the first
-    c = s.getComparable()!;
-    expect(c).toBeNull();
-
-    // // then graph is built so we can get the sort result.
-    const result = s.getResult();
-    const values = result.map((v) => v.value.value);
-    expect(values).toEqual([8, 4, 4, 3, 1]);
-
-    const ids = result.map((v) => v.value.getId());
-    expect(ids).toEqual(['0', '1', '4', '2', '3']);
-
-    const ranks = result.map((r) => r.rank);
-    expect(ranks).toEqual([1, 2, 2, 4, 5]);
-  });
-
-  it('random', () => {
-    // try to sort 70 random numbers for 100 times
-    let totalCompared = 0;
-    let maxCompared = 0;
-    let minCompared = 0;
-    for (let i = 0; i < 100; i++) {
-      const size = 70;
-      const dataset = new Array(size).fill(0, 0, size).map((v, idx) => {
-        return Math.floor(Math.random() * size);
-      });
-      const s = new HPSortTopologicalSort(dataset.map(NumberNode.fromNumber), 4, true);
-      let count = 0;
-      while (true) {
-        const comparison = s.getComparable();
-        if (comparison === null) {
-          break;
-        }
-        let max = comparison[0].value;
-        let winners = [0];
-        for (let i = 1; i < comparison.length; i++) {
-          if (comparison[i].value > max) {
-            max = comparison[i].value;
-            winners = [i];
-          } else if (comparison[i].value === max) {
-            winners.push(i);
-          }
-        }
-
-        if (winners.length === comparison.length) {
-          s.tie();
-        } else {
-          s.select(...winners);
-        }
-        count++;
-      }
-      const values = s.getResult().map((v) => v.value.value);
-      const sorted = [...dataset].sort((a, b) => b - a);
-      expect(values).toEqual(sorted);
-      expect(s.getNumCompared()).toEqual(count);
-      totalCompared += count;
-      if (maxCompared < count) {
-        maxCompared = count;
-      }
-      if (minCompared === 0 || minCompared > count) {
-        minCompared = count;
-      }
-    }
-    // we want to see the average comparison count to see how Sort works.
-    // eslint-disable-next-line no-console
-    console.log('Average comparison count:', totalCompared / 100);
-    // eslint-disable-next-line no-console
-    console.log('Max comparison count:', maxCompared);
-    // eslint-disable-next-line no-console
-    console.log('Min comparison count:', minCompared);
-  });
-});
diff --git a/expo/features/hpsort/internals/sort/HPSortTopologicalSort.ts b/expo/features/hpsort/internals/sort/HPSortTopologicalSort.ts
deleted file mode 100644
index 46f4f306..00000000
--- a/expo/features/hpsort/internals/sort/HPSortTopologicalSort.ts
+++ /dev/null
@@ -1,273 +0,0 @@
-import { shuffle } from '@hpapp/foundation/object';
-
-import HPSortBase, { HPSortProgress, HPSortResult } from './HPSortBase';
-
-export interface HPSortTopologicalSortNode {
-  getId(): string;
-}
-
-export default class HPSortTopologicalSort<T extends HPSortTopologicalSortNode> implements HPSortBase<T> {
-  private list: T[];
-  private map: Map<string, T>;
-  private numCompared: number;
-  private numCompares: number;
-  private randomize: boolean;
-  private comparable: T[] | null = null;
-
-  // a graph that maintains the comparison result. If a wins b, then we add an eddge from a to b
-  private graph: Map<string, Set<string>>;
-  // a set of pairs of which user select "tie"
-  private ties: Map<string, Set<string>>;
-  // record which ids are already compared yet
-  private compared: Map<string, Set<string>>;
-
-  constructor(list: T[], numCompares = 4, randomize = false) {
-    this.list = list;
-    this.map = new Map(list.map((v) => [v.getId(), v]));
-    this.graph = new Map(list.map((v) => [v.getId(), new Set<string>()]));
-    this.ties = new Map(list.map((v) => [v.getId(), new Set<string>()]));
-    this.compared = new Map(list.map((v) => [v.getId(), new Set<string>()]));
-    this.numCompared = 0;
-    this.randomize = randomize;
-    this.numCompares = numCompares;
-    this.updateComparable();
-  }
-
-  public select(...winnerIdx: number[]) {
-    const comprable = this.comparable;
-    if (comprable === null) {
-      return;
-    }
-    if (winnerIdx.length === 0 || comprable.length === winnerIdx.length) {
-      this.tie();
-      return;
-    }
-    const loserIdx = comprable.map((v, idx) => idx).filter((idx) => !winnerIdx.includes(idx));
-    winnerIdx.forEach((widx) => {
-      loserIdx.forEach((lidx) => {
-        this.addEdge(comprable[widx], comprable[lidx]);
-      });
-    });
-    this.numCompared++;
-    this.updateComparable();
-  }
-
-  private addEdge(winner: T, loser: T) {
-    if (this.graph.get(winner.getId())!.has(loser.getId())) {
-      // already have winner => loser edge
-      return;
-    }
-    this.graph.get(winner.getId())!.add(loser.getId());
-    this.compared.get(winner.getId())!.add(loser.getId());
-    this.compared.get(loser.getId())!.add(winner.getId());
-
-    // Transitive law
-    // winner > loser, loser > loserOfLoser    : => winner > loserOfLoser
-    for (const loserOfLoser of this.graph.get(loser.getId())!) {
-      this.addEdge(winner, this.map.get(loserOfLoser)!);
-    }
-    // winner > losser, winner > winnerOfWinner: => winnerOfWinner > loser
-    for (const winnerOfWinner of Array.from(this.graph.keys())) {
-      if (this.graph.get(winnerOfWinner)!.has(winner.getId())) {
-        this.addEdge(this.map.get(winnerOfWinner)!, loser);
-      }
-    }
-
-    // winner > loser, loser = v: => winner
-    for (const v of this.ties.get(loser.getId())!) {
-      this.addEdge(winner, this.map.get(v)!);
-    }
-    // winner > loswer, winer = v : => v > loser
-    for (const v of this.ties.get(winner.getId())!) {
-      this.addEdge(this.map.get(v)!, loser);
-    }
-  }
-
-  public tie() {
-    const comparable = this.comparable;
-    if (comparable === null) {
-      return;
-    }
-    for (const v1 of comparable) {
-      for (const v2 of comparable) {
-        if (v1.getId() !== v2.getId()) {
-          this.addTies(v1, v2);
-        }
-      }
-    }
-    this.numCompared++;
-    this.updateComparable();
-  }
-
-  private addTies(v1: T, v2: T) {
-    if (!this.ties.get(v1.getId())!.has(v2.getId())) {
-      this.ties.get(v1.getId())!.add(v2.getId());
-      this.compared.get(v1.getId())!.add(v2.getId());
-      // Transitive law
-      // v1 == v2, v2 == v3: => v1 == v3
-      for (const v3 of this.ties.get(v2.getId())!) {
-        this.addTies(v1, this.map.get(v3)!);
-      }
-    }
-    if (!this.ties.get(v2.getId())!.has(v1.getId())) {
-      this.ties.get(v2.getId())!.add(v1.getId());
-      this.compared.get(v2.getId())!.add(v1.getId());
-      // Transitive law
-      // v1 == v2, v1 == v3: => v2 == v3
-      for (const v3 of this.ties.get(v1.getId())!) {
-        this.addTies(v2, this.map.get(v3)!);
-      }
-    }
-  }
-
-  public getComparable(): T[] | null {
-    return this.comparable;
-  }
-
-  public getProgress(): HPSortProgress {
-    let numerator = 0;
-    let denominator = 0;
-    for (const [, v] of this.compared.entries()) {
-      denominator += this.list.length - 1; // total possible comparisons
-      numerator += v.size; // already compared
-    }
-    return {
-      numerator,
-      denominator
-    };
-  }
-
-  /**
-   * getNumCompared returns the number of comparisons made so far.
-   * @returns the number of comparisons made so far.
-   */
-  public getNumCompared(): number {
-    return this.numCompared;
-  }
-
-  public getResult(): HPSortResult<T> {
-    const sorted = this.topologicalSort();
-    let rank = 1;
-    return sorted.map((v, idx) => {
-      if (idx > 0) {
-        const prev = sorted[idx - 1];
-        if (!this.ties.get(prev.getId())!.has(v.getId())) {
-          // increment the rank to idx+1 only when the current is not tied with the previous.
-          rank = idx + 1;
-        }
-      }
-      return { value: v, rank };
-    });
-  }
-
-  /**
-   * topologicalSort returns the sorted list of T based on the current comparison result.
-   */
-  private topologicalSort(): T[] {
-    // we sort ids from the graph and ties, then generate T[] based on the sorted ids.
-    const inDegree = new Map<string, number>();
-    const result: string[] = [];
-    const queue: string[] = [];
-
-    for (const [node] of this.graph.entries()) {
-      inDegree.set(node, 0);
-    }
-    for (const edges of this.graph.values()) {
-      for (const edge of edges) {
-        inDegree.set(edge, (inDegree.get(edge) ?? 0) + 1);
-      }
-    }
-
-    for (const [node, degree] of inDegree.entries()) {
-      if (degree === 0) queue.push(node);
-    }
-
-    while (queue.length > 0) {
-      const node = queue.shift()!;
-      result.push(node);
-
-      for (const neighbor of this.graph.get(node)!) {
-        inDegree.set(neighbor, inDegree.get(neighbor)! - 1);
-        if (inDegree.get(neighbor) === 0) {
-          queue.push(neighbor);
-        }
-      }
-    }
-
-    const finalResult = new Set<string>(result);
-    for (const [node, ties] of this.ties.entries()) {
-      if (finalResult.has(node)) {
-        for (const tie of ties) {
-          if (!finalResult.has(tie)) result.push(tie);
-        }
-      }
-    }
-
-    return result.map((id) => this.map.get(id)!);
-  }
-
-  private findUncompared(): T[] {
-    const added = new Set<string>();
-    const uncompared: T[] = [];
-    const numCompares = this.numCompares;
-
-    const randomized = this.randomize ? shuffle(this.list) : this.list;
-    for (const v1 of randomized) {
-      if (added.has(v1.getId())) {
-        continue;
-      }
-      if (this.compared.get(v1.getId())!.size < randomized.length - 1) {
-        // v1 does not copmare with all other nodes
-        if (uncompared.length > 0) {
-          // if any of uncompared node has a comparison with v1, then we should not add v1 to the list.
-          let shouldAdd = true;
-          for (const v2 of uncompared) {
-            if (this.compared.get(v1.getId())!.has(v2.getId()) || this.compared.get(v2.getId())!.has(v1.getId())) {
-              shouldAdd = false;
-            }
-          }
-          if (!shouldAdd) {
-            continue;
-          }
-        }
-        uncompared.push(v1);
-        added.add(v1.getId());
-        if (!added.has(v1.getId())) {
-          if (uncompared.length >= numCompares) {
-            return uncompared;
-          }
-        }
-
-        for (const v2 of randomized) {
-          if (v1.getId() === v2.getId()) {
-            continue;
-          }
-          if (this.compared.get(v1.getId())!.has(v2.getId()) || this.compared.get(v2.getId())!.has(v1.getId())) {
-            continue;
-          }
-          if (added.has(v2.getId())) {
-            continue;
-          }
-          // v2 does not compare with v1, so add it.
-          uncompared.push(v2);
-          added.add(v2.getId());
-
-          if (uncompared.length >= numCompares) {
-            return uncompared;
-          }
-        }
-      }
-    }
-    return uncompared;
-  }
-
-  private updateComparable() {
-    const uncompared = this.findUncompared();
-    if (uncompared.length <= 1) {
-      this.comparable = null;
-      return;
-    }
-    this.comparable = uncompared;
-    return this.comparable;
-  }
-}