立候補者の知名度差および組織票の影響を軽減する零和投票方式について

●問題意識
現状の選挙では当落がマニュフェストを良し悪しの他に候補者の知名度にも大きく依存する。そのため、知名度が低い候補者はマニュフェストの良さや自身の力量のみによって当選を果たすことが非常に困難である。
そればかりか、選挙戦が知名度合戦の様相を呈することで、多くの候補者が知名度を高めるための非本質的な部分に労力を投下する必要がでてきてしまう。
僕はその不公平さと不毛さを解消したいと考えた。

●具体的提案
僕が提案するのは選挙を「最も支持する候補者に票を投じる手続き」ではなく、「最も支持しない候補者から最も支持する候補者に票を移動する手続き」とすることである。
これによって、知名度の向上が単に得票機会の創出だけでなく、失票の可能性を高めることにも繋がる。
※得票数は負の値も取りうる。全候補者の得票数の合計は常に0になる。

●懸念点
ただし、上述の零和投票方式は組織的不正に脆弱である。つまり、ある候補者の支持者集団が競合する別の候補者の票を組織的に減らすという不正が考えられてしまう。
それに対する防止策そして、候補者の評価スコアに得票数ではなく、得票数を初期条件として与えた固有ベクトル中心性ないしそれに類する中心性のスコアを採用することを検討している。(添付画像を参照)



「いいね!」 4

ご意見いただけると幸いです。

「いいね!」 1

画像の内容を文字として送ってくれますか…?AIと相談しながら、考えたいです。
ちなみに以下のようにやると、コンパクトに投稿できます!

<details>
<summary>
タイトル
</summary>
本文
</details>

よろしくお願いします!

「いいね!」 3

あ、そういう共有方法がありましたね、失念してました⋯(恥ずかしい)

頑張って理解しようとしたんだけど、全然理解できひんかった(泣)
組織票対策は個人の投票先の変遷を追跡するってことですか?

えーっと、自然言語だと説明しづらいんですが、今考えてるのは以下のようなアルゴリズムです!

# 一人目の候補者は全員から1票ずつ、
# 二人目の候補者は全員から2票ずつ、
# 三人目の候補者は一人目の候補者から9票、
# 四人目の候補者は二人目の候補者から9票、
# 五人目の候補者は一人目の候補者から4票、二人目の候補者から5票、三人目の候補者から2票、四人目の候補者から7票
# という状況を行列で表現したのがA
A=[[0,1,1,1,1],
   [2,0,2,2,2],
   [9,0,0,0,0],
   [0,9,0,0,0],
   [4,5,2,7,0]]



# まずはプラス票のみを考えて各候補者の得票率を算出したのがvotes
votes = [0,0,0,0,0]
for i in range(5):
    for j in range(5):
        votes[i] = votes[i] + A[i][j]
sum_votes = sum(votes)
for i in range(5):
    votes[i] = votes[i]/sum_votes
print(votes)


# 次に候補者Aから候補者Bへの票の移動を考える
# 移動した票は候補者Bの得票率で重み付けされて候補者Aの得点に加算される(この得点の分布がp)
# 以降はpを新たな得票率として、新たなpを求める
# 同様の操作を100回程度繰り返す
for h in range(100):
    p = [0,0,0,0,0]
    for i in range(5):
        for j in range(5):
            p[i] = p[i] + A[i][j]*votes[j]
    sum_p = sum(p)
    for i in range(5):
        p[i] = p[i]/sum_p
    votes = p
    print(votes)

# そうすると、各候補者の得点pの分布は一定の値に収束する
# この値の大小関係で当落を決める
「いいね!」 1

以上のようなアルゴリズムを採用した場合、

初期条件(最初の得票率)は以下のようになります。
8%, 17%, 19%, 19%, 38%

そして票の移動も考慮した得点は以下のようになりました。
11%, 19%, 12%, 21%, 37%

この例ですと3人目と4人目の最初の得票率はまったく同じなのですが、両者の票はそれぞれ1人目と2人目から移動してきた票なので、初期条件で得票率が高かった2人目から票を得た4人目の候補者が最終的には3人目より高い得点を得ることになります。

すみません、訂正です。
**”候補者Bから候補者Aへの票の移動”**です。

前回の都知事選の得票数を使ってシミュレーションしてみました。
票の移動は、下記の様に設定しました。
koikeさんに投票した60%がrenhouさんから、40%がishimaruさんから移動。
ishimaruさんに投票した90%がkoikeさんから、10%がrenhouさんから移動。
renhouさんに投票した90%がkoikeさんから、10%がishimatruさんから移動。
他の候補者に投票した人は100%がkoikeさんから、各候補者に移動。

import numpy as np
import matplotlib.pyplot as plt

# 得票率計算
def calVotes(A, tnum):
  num, _ = A.shape
  votes = np.ones(num)
  p = np.zeros(num)
  votes_log = np.zeros((tnum, num))

  for t in range(tnum):
    p = A@votes
    sum_p = sum(p)
    votes = p/sum_p
    p = votes
    votes_log[t, :] = votes

  return(votes_log)

# 2024年都知事選挙 候補者名
cname = ['koike', 'ishimaru', 'renhou', 'tamogami', 'anno', 'utsumi', 'himasora', 'ishimaru', 'sakurai',
 'shimizu', 'dokutaanakamatsu', 'yamato', 'kobayashi', 'gotou', 'kimiya', 'fukumoto', 'eiaimeiyaa', 'naitou',
 'yokoyama', 'uchino', 'kawai', 'kougo', 'kurokawa', 'kuwahara', 'fukunaga', 'nomaguchi', 'sawa', 'ushikubo',
 'komatsu', 'endou', 'ninomiya', 'takemoto', 'akinorishougunmiman', 'onodera', 'yamada', 'kimura', 'shindou',
 'nakae', 'katou', 'kagata', 'katou', 'hokari', 'maeda', 'kusao', 'fukuhara', 'takeuchi', 'ozeki', 'inubuse',
 'kuwajima', 'matsuo', 'furuta', 'funahashi', 'miwa', 'tsumura', 'minami', 'jouraku']
# 2024年都知事選挙 得票数
vote = [2918015, 1658363, 1283262, 267699, 154638, 121715, 110196, 96222, 83600, 38054, 23825, 9685,
 7408, 5419, 4874, 3245, 2761, 2339, 2174, 2152, 2035, 1951, 1833, 1747, 1281, 1240, 1232, 1153, 894,
 882, 833, 812, 792, 759, 691, 676, 669, 612, 588, 578, 572, 560, 521, 481, 466, 446, 417, 371, 361, 351,
 343, 329, 306, 302, 297, 211]

num = len(vote)
tnum = 100

# 票の移動量設定
A = np.zeros((num, num))

A[0,1] = vote[0]*0.4  # ishimaru -> koike 40%
A[0,2] = vote[0]*0.6  # renhou -> koike 60%
A[1,0] = vote[1]*0.9  # koike -> ishimaru 90%
A[1,2] = vote[1]*0.1  # renhou -> ishimaru 10%
A[2,0] = vote[2]*0.9  # koike -> renhou 90%
A[2,1] = vote[2]*0.1  # ishimaru -> renhou 10%
A[3:num, 0] = vote[3:num] # koike -> each Candidates 100%

# 得票率計算
v_log = calVotes(A, tnum)

# 結果表示
plt.plot(v_log[:, :5])
plt.legend(cname[:5], loc='lower right')
plt.grid()
plt.title('Convergence of vote share')
plt.ylabel('Vote share') 
print('候補者名        ', cname[:5])
print('最初の得票率[%]', v_log[0, :5]*100)
print('票の移動も考慮した得点[%]', v_log[tnum-1, :5]*100)

結果
候補者名 [‘koike’, ‘ishimaru’, ‘renhou’, ‘tamogami’, ‘anno’]
最初の得票率[%] [42.76583933 24.30463367 18.80722906 3.92334255 2.26634334]
票の移動も考慮した得点[%] [34.55931077 27.36789452 21.54806788 4.59076591 2.65188461]

票の移動はishimaruさんに有利な設定と思われますが、逆転までには至らなかったです。今回のアルゴリズムでは、そこそこ競っていないと逆転は難しいようです。嫌われない人が有利なので、現職より新人が有利になると考えられるので、そこは良いかなと思います。

「いいね!」 2

返信が遅れてすみません⋯理解に時間がかかりました

上のコードだと、有権者が「指示する人」と「支持しない人」に投票するのではなく、
通常の投票の後に、立候補者が他の人に票を推薦として分配するシステムに思えます⋯

「いいね!」 2

すみません・・・
最初の投票結果を零和にする処理をしていませんでした。
コード修正しました。

import matplotlib.pyplot as pyplot
import numpy as np

A=[[0,10,30,10,10],
   [15,0,15,15,15],
   [10,10,0,10,10],
   [10,10,10,0,10],
   [10,10,10,10,0]]

B=[[0,0,0,0,0],
   [0,0,0,0,0],
   [0,0,0,0,0],
   [0,0,0,0,0],
   [0,0,0,0,0]]

for i in range(5):
    for j in range(5):
        B[i][j] = A[i][j] - A[j][i]

votes = [0,0,0,0,0]
for i in range(5):
    for j in range(5):
        votes[i] = votes[i] + B[i][j]
sqsum_votes = ((votes[0])**2+(votes[1])**2+(votes[2])**2+(votes[3])**2+(votes[4])**2)**0.5
for i in range(5):
    votes[i] = votes[i]/sqsum_votes
for i in range(5):
    votes[i] = votes[i] 
print(votes)
plt=pyplot.bar([1,2,3,4,5],votes)
pyplot.show()

rireki = []
rireki.append(votes)
for h in range(40):
    p = [0,0,0,0,0]
    for i in range(5):
        for j in range(5):
            p[i] = p[i] + A[j][i]*votes[j]
    sqsum_p = ((p[0])**2+(p[1])**2+(p[2])**2+(p[3])**2+(p[4])**2)**0.5
    for i in range(5):
        p[i] = p[i]/sqsum_p
    votes = p
    rireki.append(votes)

rireki_array = np.array(rireki)

for i in range(5):
    pyplot.plot(rireki_array[:,i])
    
pyplot.xlabel('Iteration')
pyplot.ylabel('Score')
pyplot.show()

print(votes)
plt=pyplot.bar([1,2,3,4,5],votes)
pyplot.show()
「いいね!」 1

ちなみに僕自身、ちょっと触った感じではあまり妥当な結果になっていない印象がありました。(なんだかボツくさいかもです・・)

「いいね!」 1

現在までの議論をもとに、AIによる意見まとめが生成されました!
ぜひ見てみてくださいね。

特に「票の移動を伴う選挙シミュレーションにおいて、候補者間の競争状況は結果にどの程度影響を与えるべきか?」という点について、特に多様な意見が出ているようです。

新たな論点

票の移動を伴う選挙シミュレーションにおいて、候補者間の競争状況は結果にどの程度影響を与えるべきか?

1. 競争激化容認派

このスタンスでは、シミュレーションにおける候補者間の競争を積極的に反映させるべきだと考えます。現実の選挙と同様に、有権者は候補者の政策、能力、戦略など様々な要素に基づいて投票行動を決定するため、シミュレーションにおいても、そうした要素を詳細に反映させるべきだという立場です。競争が激化するほど、有権者の選択肢は増え、結果も多様化すると考えます。

メリット: より現実的なシミュレーション結果が得られる可能性、有権者の多様な価値観を反映できる、候補者の戦略の有効性を検証できる。デメリット: シミュレーションの複雑化、データの収集と分析の困難さ、シミュレーション結果の解釈の難しさ、特定の候補者に有利な結果が出る可能性。

2. 逆転困難是正派

このスタンスでは、シミュレーションにおいて、競争状況の影響をある程度制限し、逆転が困難な状況を是正することを目指します。現実の選挙では、資金力や組織力、知名度など、様々な要因が選挙結果に影響を与え、必ずしも政策や能力だけで勝敗が決まるわけではありません。シミュレーションにおいても、そうした要素を考慮し、不当な逆転を抑制するような調整が必要だと考えます。

メリット: 公正性の高いシミュレーション結果、弱者救済的な視点の反映、シミュレーション結果の安定性。デメリット: 競争の激しさが反映されにくい、現実の選挙結果との乖離、シミュレーションの恣意性の問題、イノベーションの阻害。

3. 中立性重視派

このスタンスでは、シミュレーション結果の中立性を最大限に重視し、競争状況の影響を最小限に抑えることを目指します。特定の候補者や政党に有利な結果が出ないよう、公平な条件でシミュレーションを行うことが重要だと考えます。シミュレーションの目的は、特定の政策や戦略の優劣を評価することではなく、あくまでも有権者の投票行動を分析することにあるという立場です。

メリット: シミュレーション結果の客観性、政策比較の公平性、多様な意見の反映。デメリット: 現実との乖離、シミュレーション結果の退屈さ、刺激のなさ。変化を生まない可能性。

上記3つのスタンス以外にも、様々な考え方があると思います。例えば、競争状況の反映度合いを調整可能なシミュレーションモデル、あるいは、現実の選挙結果を参考に、シミュレーション結果を調整する手法など、様々な方法が考えられます。

上記の議論を参考に、あなたの意見を教えて下さい!もし、あなたが考える新しいアプローチがあれば、ぜひ教えてください。

「いいね!」 2

度々すみません。
先ほど上げたコードを微修正しました。
具体的には最終的な得点をvotesではなく1-votesとし、votesが低い人ほど得点が高くなるようにしました。(1-votesの値をsaisyuutekina_scoreとして3枚目のグラフに表示されるようにしました。)
これによって最終的なスコアが高い人を当選とすることで、初期の得票数が数倍違う候補者同士が互角に戦うことができるようになり、スコアの高低は基本的に維持されつつ、ちょくちょく逆転も起こるようになりました。

これからこのシステムがちゃんと組織票の影響を排除しているのかを検証していきたいと思います。

import matplotlib.pyplot as pyplot
import numpy as np
import random as ra

A=[[0,ra.random(),ra.random(),ra.random(),ra.random()],
   [ra.random(),0,ra.random(),ra.random(),ra.random()],
   [ra.random(),ra.random(),0,ra.random(),ra.random()],
   [ra.random(),ra.random(),ra.random(),0,ra.random()],
   [ra.random(),ra.random(),ra.random(),ra.random(),0]]

B=[[0,0,0,0,0],
   [0,0,0,0,0],
   [0,0,0,0,0],
   [0,0,0,0,0],
   [0,0,0,0,0]]

for i in range(5):
    for j in range(5):
        B[i][j] = A[i][j] - A[j][i]

votes = [0,0,0,0,0]
for i in range(5):
    for j in range(5):
        votes[i] = votes[i] + B[i][j]
sqsum_votes = ((votes[0])**2+(votes[1])**2+(votes[2])**2+(votes[3])**2+(votes[4])**2)**0.5
for i in range(5):
    votes[i] = votes[i]/sqsum_votes
print(votes)
plt=pyplot.bar([1,2,3,4,5],votes)
pyplot.show()

rireki = []
rireki.append(votes)
for h in range(40):
    p = [0,0,0,0,0]
    for i in range(5):
        for j in range(5):
            p[i] = p[i] + A[j][i]*votes[j]
    sqsum_p = ((p[0])**2+(p[1])**2+(p[2])**2+(p[3])**2+(p[4])**2)**0.5
    for i in range(5):
        p[i] = p[i]/sqsum_p
    votes = p
    rireki.append(votes)

rireki_array = np.array(rireki)

for i in range(5):
    pyplot.plot(rireki_array[:,i])
    
pyplot.xlabel('Iteration')
pyplot.ylabel('Score')
pyplot.show()

saisyuutekina_score = []
for i in range(5):
    saisyuutekina_score.append(1-votes[i])
print(saisyuutekina_score)
plt=pyplot.bar([1,2,3,4,5],saisyuutekina_score)
pyplot.show()

↓初期条件(零和になっている)


↓中心性を計算している過程(ちゃんと一定の値に収束している)

↓最終的なスコア

「いいね!」 1

頓珍漢な質問だったらごめんなさい
このコードにおいて投票者の行動はどう現れてくるのですか?

「いいね!」 2

例えば、2番目の候補者から1番目の候補者に票を移動した場合、A[1][2]の値が1増えてA[2][1]は1減ります。

「いいね!」 1

固有ベクトル中心性は、初期値によらず同じ値に収束するので、固有ベクトル中心性を計算する前のvotesの計算は固有ベクトル中心性には影響を与えないと思います。
試しに、votes=[1,1,1,1,1]にして計算しても固有ベクトル中心性の計算結果は同じになりました。下記コードと結果を参照。

import matplotlib.pyplot as pyplot
import numpy as np
import random as ra

A=[[0,ra.random(),ra.random(),ra.random(),ra.random()],
   [ra.random(),0,ra.random(),ra.random(),ra.random()],
   [ra.random(),ra.random(),0,ra.random(),ra.random()],
   [ra.random(),ra.random(),ra.random(),0,ra.random()],
   [ra.random(),ra.random(),ra.random(),ra.random(),0]]

B=[[0,0,0,0,0],
   [0,0,0,0,0],
   [0,0,0,0,0],
   [0,0,0,0,0],
   [0,0,0,0,0]]

for i in range(5):
    for j in range(5):
        B[i][j] = A[i][j] - A[j][i]

votes = [0,0,0,0,0]
for i in range(5):
    for j in range(5):
        votes[i] = votes[i] + B[i][j]
sqsum_votes = ((votes[0])**2+(votes[1])**2+(votes[2])**2+(votes[3])**2+(votes[4])**2)**0.5
for i in range(5):
    votes[i] = votes[i]/sqsum_votes
print(votes)
plt=pyplot.bar([1,2,3,4,5],votes)
pyplot.show()


rireki = []
rireki.append(votes)
for h in range(40):
    p = [0,0,0,0,0]
    for i in range(5):
        for j in range(5):
            p[i] = p[i] + A[j][i]*votes[j]
    sqsum_p = ((p[0])**2+(p[1])**2+(p[2])**2+(p[3])**2+(p[4])**2)**0.5
    for i in range(5):
        p[i] = p[i]/sqsum_p
    votes = p
    rireki.append(votes)

rireki_array = np.array(rireki)

for i in range(5):
    pyplot.plot(rireki_array[:,i])
    
pyplot.xlabel('Iteration')
pyplot.ylabel('Score')
pyplot.show()

saisyuutekina_score = []
for i in range(5):
    saisyuutekina_score.append(1-votes[i])
print(saisyuutekina_score)
plt=pyplot.bar([1,2,3,4,5],saisyuutekina_score)
pyplot.show()

###################################################
# votesの初期値を[1,1,1,1,1]にして、同じ計算をする。
#
votes = [1,1,1,1,1]
rireki = []
rireki.append(votes)
for h in range(40):
    p = [0,0,0,0,0]
    for i in range(5):
        for j in range(5):
            p[i] = p[i] + A[j][i]*votes[j]
    sqsum_p = ((p[0])**2+(p[1])**2+(p[2])**2+(p[3])**2+(p[4])**2)**0.5
    for i in range(5):
        p[i] = p[i]/sqsum_p
    votes = p
    rireki.append(votes)

rireki_array = np.array(rireki)

for i in range(5):
    pyplot.plot(rireki_array[:,i])
    
pyplot.xlabel('Iteration')
pyplot.ylabel('Score')
pyplot.show()

saisyuutekina_score = []
for i in range(5):
    saisyuutekina_score.append(1-votes[i])
print(saisyuutekina_score)
plt=pyplot.bar([1,2,3,4,5],saisyuutekina_score)
pyplot.show()

結果
kusha_kushiyaさんのvotesを初期として固有ベクトル中心性を計算した結果


収束値

[1,1,1,1,1]を初期値として計算した結果。収束値は上記と同じ。

収束値

どうでしょうか?

あと
p[i] = p[i] + A[j][i]*votes[j]は
p[i] = p[i] + A[i][j]*votes[j]の間違いではないでしょうか?

ちなみに固有ベクトル中心性は下記のようなグラフで、ノードを評価する指標とのことです。単に票がたくさんあつまっているだけではなく重要なノードから票がたくさん集まるとポイントがあがるような指標みたいです。下記のグラフの見方は、ノード(丸の部分)が候補者、エッジ(線の部分)に記載している数値が移動する票です。例えば、2から1への移動は0.93、1から2への移動は0.84というような感じで表しています。

「いいね!」 1

うーむ。
たしかに、おっしゃる通りのようですね・・。

現在までの議論をもとに、AIによる意見まとめが生成されました!
ぜひ見てみてくださいね。

特に「選挙シミュレーションにおいて、競争状況(資金力、組織力など)の影響をどこまで反映させるべきか?」という点について、様々な意見が出ているようです。

新たな論点

選挙シミュレーションにおいて、競争状況(資金力、組織力など)の影響をどこまで反映させるべきか?

1. 現実反映重視派

このスタンスでは、選挙シミュレーションにおいて、候補者の資金力、組織力、戦略といった競争状況を積極的に反映させるべきと考えています。現実の選挙と同様に、有権者の多様な要素に基づく投票行動をシミュレーションに組み込むことで、よりリアルな結果を目指します。

メリット: より現実的なシミュレーション結果が得られる、有権者の多様な視点を反映できる。
デメリット: 特定の候補者に有利な結果になりやすい、データの収集と分析が複雑になる。

2. 中立性重視派

このスタンスでは、選挙シミュレーションの中立性を最優先し、競争状況の影響をある程度制限することを目指します。特定の候補者に有利にならないよう、公平な条件でシミュレーションを行い、有権者の投票行動の分析に特化することで、客観的な結果を追求します。

メリット: 公平性の高いシミュレーション結果が得られる、偏りのないデータ分析が可能になる。
デメリット: 現実の選挙の複雑さを十分に反映できない可能性がある、結果の解釈が難しくなる。

議論を深めるために

どちらのスタンスにも、それぞれメリットとデメリットがあります。もし、まず始めるなら、リソースには限りがあるという前提で、どちらの要素を優先すべきでしょうか?

  • 現実的なシミュレーションを目指す:競争状況を積極的に反映し、よりリアルな結果を追求する。
  • 中立性を重視する:公平な条件でシミュレーションを行い、客観的な分析を行う。

どちらか一方に偏る必要はありません。例えば、まずは中立性を重視したシミュレーションを行い、その上で、競争状況の影響を段階的に加えていく、という方法も考えられます。それぞれの意見を参考に、あなたの考えを教えてください!

このトピックについて、上記以外にも様々な意見があるはずです。多様な視点からのコメントをお待ちしています!

組織票に関して相談しながら考えたのだけど、

  • ある無名な候補者をマイナス評価する

のなら対策として効果あれど、

  • 複数の候補者ないし人気候補者をマイナス評価する

といった方法に対しては脆弱であるような気がして、その対策をchatGPTに聞いてみたら、機械学習によって柔軟に不正操作を検知するといったある意味対処療法的な回答が返ってきました⋯

「いいね!」 2