先までは、"愛記"についての記載で、どのようにブロックチェーンSNSに組み込んで実装していけばよいのか、概念的なところからアプローチ方法を記載していった。大まかな概念としてはひとまず終えた。次は、ブロックチェーンの概念設計といえるところまで、基本設計書に着手できるようなところまで、概念を具体化していきたい。
個人の評価項目について④
愛の行動の評価は何を規準に、どのようになされていくのであろうか。そこを記載したい。先に評価項目について記載した。評価を設計するに際し、コンピテンシーなる標準行動を考えていくべきなのであろう。この標準行動をとるような人が設計のモデルとなり、そこからどれほどバラつくかを設計していくことで良いのだろう。
・”ゆらぎ”件数：３件/月以上
・対象相手：偏りすぎないこと
・次元：偏りすぎないこと
・波動レベル：偏りすぎないこと
・愛の行動量：30回/月以上
これらの状態を見える化する、つまりはフィードバックすることがなによりも、落ちていることを自分に気づかせる手段なのであり、”愛記”により、一目瞭然となるのである！とても分かりやすいフィードバックであるので、自己理解ツールにもなり得るだろう。
◆次元が偏りすぎない について
前回、”ゆらぎ”について記載した。今回は次元について見てみよう。組織での次元の評価は以前にも記載したので、今回は個人での次元が偏りすぎないかどうかの評価を記載する。
まずは、各次元の生命体をイメージすることから始まる。それを市町村のブロックチェーンSNSの参入の最初に、初期設定として、自分の状態を設定してもらう必要がある。市町村に”愛記システム”に参加の申し込みをし、年間にどれほどの愛の行動をしてくれるのかの宣言をしてもらうことから始まる。しかも、その宣言は次元毎であり、各次元に複数の生命体を設定したい場合は最初にそのような申告をする。具体的には下記のようになる。
・氏名：石川太郎、在住：石川県加賀市、他はマイナンバーカードと紐付け
Total: 8000000愛貨を行動宣言
第10次元：太陽系（デフォルト）
第9次元：地球（デフォルト）
第9次元：飲み水を守る会（記入した）における”脳の役割”で発足
第8次元：人類（デフォルト）における”腸の役割”で参画
第7次元：世界経済（デフォルト）
第6次元：日本国（デフォルト）における”脊髄の役割”で参画
第6次元：日本国を動かしていこう会（記入した）における”右足の役割”で参画
第5次元：情報通信業（選択した）
第5次元：石川県（選択した）
第4次元：情報サービス業（選択した）
第4次元：加賀市（選択した）
第4次元：（一社）石川県情報システム工業会（記入した）
第3次元：株式会社スマートバリュー（記入した）における”左足の役割”で参画
第3次元：加賀市ブロックチェーン都市構想プロジェクト（記入した）
第2次元：技術営業部（記入した）
第2次元：アプリ開発チーム（記入した）における”脳の役割”で発足
第2次元：KYC認証チーム（記入した）における”顔の役割”で参画
第1次元：個人（デフォルト）
このように、各次元における”役割”を初期画面で設定することで、ようやくその生命体を選択して愛の行動ができるようになるのだ。上記の太字・下線になっている生命体のみが選択可能という具合だ。例えば、第８次元：人類という立場にて、自分は愛の行動を選択し、相手に受け取ってもらえたとしよう。
・借方（発信先）：第８次元_人類_自分 、瞑想し無意識になる
→ 詳細内容を備考欄に記入。
・貸方（受信側）：第８次元_人類_Oさん 、気持ちが楽になる
→ 背景等を備考欄に記入。
このような仕訳が成立する。もし、初期設定画面で各生命体の”役割”を設定していなければ、愛の行動をしようと思って次元を選択しようとしても、選択できないということになる。
・DApps側であるPythonプログラム
では、次元が偏りすぎていないかどうかを評価するDApps側であるPythonプログラムを構築したい。例えば、DApps側で評価というボタンを押せば、現時点での次元の偏りを表示できるような仕組みにしたい。それには、各次元の各生命体で何件ずつ愛の行動を行っているのかの集計が必要だし、偏り評価を数学的なアルゴリズムで評価する仕組みも必要だろう。
なお、次元の難易度を考慮するアプローチのような場合、各次元の難易度を定量化して、それに基づいて偏り評価を行うことができる。具体的には、各次元に対して難易度係数を設定し、それを元に愛の行動件数を補正することが考えられる。例えば、1次元が基準となる場合、1次元の難易度係数を1とし、10次元の難易度係数を10と設定する。そして、各生命体が行った愛の行動件数を、各次元の難易度係数で割って補正する。これにより、より高次元の行動がより重視されるようになる。ただし、このような難易度係数を設定する場合、どのような基準でそれぞれの次元の難易度を定義するかが重要である。一般的な基準を設けることも考えられるが、システムの設計者が独自の基準を設定することもできる。
from collections import defaultdict
class DimensionEvaluation:
def __init__(self):
self.dimension_actions = defaultdict(int)
self.dimension_difficulty = {
'太陽系': 10,
'地球': 9,
'飲み水を守る会': 8,
'人類': 7,
'世界経済': 6,
'日本国': 5,
'石川県': 4,
'情報通信業': 3,
'石川県情報システム工業会': 3,
'株式会社スマートバリュー': 3,
'加賀市ブロックチェーン都市構想プロジェクト': 3,
'技術営業部': 2,
'アプリ開発チーム': 2,
'KYC認証チーム': 2,
'個人': 1
}
def add_action(self, dimension, count=1):
self.dimension_actions[dimension] += count
def evaluate(self):
# Apply difficulty coefficients
adjusted_actions = {dimension: count / self.dimension_difficulty[dimension] for dimension, count in self.dimension_actions.items()}
# Calculate average actions per dimension
total_actions = sum(adjusted_actions.values())
num_dimensions = len(self.dimension_actions)
average_actions = total_actions / num_dimensions if num_dimensions > 0 else 0
# Calculate standard deviation
variance = sum((count - average_actions) ** 2 for count in adjusted_actions.values()) / num_dimensions
std_deviation = variance ** 0.5
# Evaluate imbalance using standard deviation
imbalance_threshold = 1.5 # Adjust as needed
is_imbalanced = std_deviation > imbalance_threshold
return is_imbalanced, std_deviation, average_actions, self.dimension_actions
# Sample data
evaluation = DimensionEvaluation()
evaluation.add_action('太陽系', 0) # Placeholder for default dimension
evaluation.add_action('地球', 0) # Placeholder for default dimension
evaluation.add_action('飲み水を守る会', 2)
evaluation.add_action('人類', 0) # Placeholder for default dimension
evaluation.add_action('世界経済', 0) # Placeholder for default dimension
evaluation.add_action('日本国', 0) # Placeholder for default dimension
evaluation.add_action('石川県', 0) # Placeholder for default dimension
evaluation.add_action('情報通信業', 0) # Placeholder for default dimension
evaluation.add_action('石川県情報システム工業会', 0)
evaluation.add_action('株式会社スマートバリュー', 0)
evaluation.add_action('加賀市ブロックチェーン都市構想プロジェクト', 0)
evaluation.add_action('技術営業部', 0)
evaluation.add_action('アプリ開発チーム', 0)
evaluation.add_action('KYC認証チーム', 0)
evaluation.add_action('個人', 10)
# Evaluate dimension imbalance
is_imbalanced, std_deviation, average_actions, dimension_actions = evaluation.evaluate()
# Display results
print("Dimension Actions:")
for dimension, count in dimension_actions.items():
print(f"{dimension}: {count} actions")
print(f"\nAverage Actions per Dimension: {average_actions}")
print(f"Standard Deviation: {std_deviation}")
print(f"Is Imbalanced?: {is_imbalanced}")
このプログラムは、各次元における愛の行動件数を集計し、平均値と標準偏差を計算して次元の偏りを評価している。最終的な評価結果として、偏りがあるかどうかを表示する。そして、各次元の難易度係数を設定し、行動件数をその係数で除して補正している。不均衡度を評価するために、補正された行動件数の平均と標準偏差を計算し、一定の閾値を超えるかどうかで不均衡度も判定している。
・DApps側と繋がるスマートコントラクトのプログラム
次に、Rustで市町村のブロックチェーンプラットフォームに接続するスマートコントラクトを開発しよう。まず、スマートコントラクトが行う基本的な機能を確認しよう。具体的には、ユーザーが評価ボタンを押すと、必要なデータを要求し、評価を行う機能を実装する。その後、ブロックチェーンにトランザクションを送信する方法を追加する。以下に、このスマートコントラクトの基本的な構造を示す：
use std::collections::HashMap;
struct DimensionEvaluation {
dimension_actions: HashMap<String, u32>,
dimension_difficulty: HashMap<String, u32>,
}
impl DimensionEvaluation {
fn new() -> Self {
let mut dimension_difficulty = HashMap::new();
dimension_difficulty.insert("太陽系".to_string(), 10);
dimension_difficulty.insert("地球".to_string(), 9);
// 他の次元も同様に追加
DimensionEvaluation {
dimension_actions: HashMap::new(),
dimension_difficulty,
}
}
fn add_action(&mut self, dimension: &str, count: u32) {
self.dimension_actions.insert(dimension.to_string(), count);
}
fn evaluate(&self) -> (bool, f64, f64) {
let total_actions: u32 = self.dimension_actions.values().sum();
let num_dimensions = self.dimension_actions.len() as f64;
let average_actions = total_actions as f64 / num_dimensions;
let variance = self.dimension_actions.values().map(|count| {
let diff = (*count as f64 - average_actions).powi(2);
diff
}).sum::<f64>() / num_dimensions;
let std_deviation = variance.sqrt();
let imbalance_threshold = 1.5; // Adjust as needed
let is_imbalanced = std_deviation > imbalance_threshold;
(is_imbalanced, std_deviation, average_actions)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_add_action() {
let mut evaluation = DimensionEvaluation::new();
evaluation.add_action("太陽系", 0);
assert_eq!(evaluation.dimension_actions.get("太陽系"), Some(&0));
}
// Add more tests as needed
}
このコードは、DimensionEvaluation構造体を使用して次元のアクション数を追跡し、評価するための機能を提供する。また、評価結果を返すevaluateメソッドも含まれている。このスマートコントラクトを使用するPythonプログラムは、スマートコントラクトが提供する関数を呼び出すことで、ブロックチェーンプラットフォームにデータを要求し、評価を行うことができる。
・市町村のブロックチェーンのrustのプログラム
なお、市町村のブロックチェーンのプログラムをrustに置き換えてやってみたので、以下に記す。この市町村のブロックチェーンのプログラムに上記のスマートコントラクトが実装され、DApps側であるPythonプログラムからスマートコントラクトが呼び出される度に、評価が実行されるという具合だ。
use chrono::{DateTime, Local};
use rand::{CryptoRng, Rng};
use sha2::{Digest, Sha256};
use std::collections::HashMap;
struct Wallet {
address: String,
balance: f64,
}
impl Wallet {
fn new(address: &str) -> Self {
Wallet {
address: address.to_string(),
balance: 0.0,
}
}
fn add_balance(&mut self, amount: f64) {
self.balance += amount;
}
fn subtract_balance(&mut self, amount: f64) -> Result<(), &'static str> {
if self.balance >= amount {
self.balance -= amount;
Ok(())
} else {
Err("Insufficient balance")
}
}
}
struct Transaction {
transaction_id: String,
sender: String,
receiver: String,
timestamp: String,
location: String,
love_action_level: u32,
amount: f64,
action_content: String,
approval_target: String,
zero_knowledge_proof: Option<()>, // Placeholder for actual proof
sender_dimension: u32,
receiver_dimension: u32,
validators: Vec<String>,
}
impl Transaction {
fn new(
sender: &str,
receiver: &str,
location: &str,
love_action_level: u32,
action_content: &str,
sender_dimension: u32,
receiver_dimension: u32,
approver: &str,
approver_dimension: u32,
) -> Self {
Transaction {
transaction_id: format!("{:x}", rand::random::<u128>()),
sender: sender.to_string(),
receiver: receiver.to_string(),
timestamp: Local::now().to_string(),
location: location.to_string(),
love_action_level,
amount: 0.0,
action_content: action_content.to_string(),
approval_target: approver.to_string(),
zero_knowledge_proof: None,
sender_dimension,
receiver_dimension,
validators: Vec::new(),
}
}
fn generate_proof_of_place(&self) -> String {
format!(
"Transaction {}'s proof of place has been generated: {}",
self.transaction_id, self.location
)
}
fn generate_proof_of_history(&self) -> String {
format!(
"Transaction {}'s proof of history has been generated: {}",
self.transaction_id, self.timestamp
)
}
fn generate_zero_knowledge_proof(&mut self) {
// Placeholder implementation
self.zero_knowledge_proof = Some(());
}
fn transfer_token(&self, love_currency: &str) {
println!(
"Token transfer: {} token transferred from {} to {} in dimension {}.",
love_currency, self.sender, self.receiver, self.receiver_dimension
);
}
fn pay_reward_to_approver(&self, reward_amount: f64, wallets: &mut HashMap<String, Wallet>) {
if let Some(approver_wallet) = wallets.get_mut(&self.approval_target) {
approver_wallet.add_balance(reward_amount);
}
}
}
struct Block {
index: u32,
previous_hash: String,
timestamp: String,
data: String,
proof_of_place: String,
proof_of_history: String,
zero_knowledge_proof: Option<()>, // Placeholder for actual proof
hash: String,
}
impl Block {
fn new(
index: u32,
previous_hash: &str,
data: &str,
proof_of_place: &str,
proof_of_history: &str,
zero_knowledge_proof: Option<()>,
) -> Self {
Block {
index,
previous_hash: previous_hash.to_string(),
timestamp: Local::now().to_string(),
data: data.to_string(),
proof_of_place: proof_of_place.to_string(),
proof_of_history: proof_of_history.to_string(),
zero_knowledge_proof,
hash: String::new(), // Placeholder for actual hash
}
}
fn calculate_hash(&mut self) {
let hash_data = format!(
"{}{}{}{}{}{}{}",
self.index,
self.previous_hash,
self.timestamp,
self.data,
self.proof_of_place,
self.proof_of_history,
match &self.zero_knowledge_proof {
Some(_) => "1",
None => "0",
}
);
let hash = Sha256::digest(hash_data.as_bytes());
self.hash = format!("{:x}", hash);
}
}
struct Blockchain {
chain: Vec<Block>,
validators: Vec<String>,
current_validators: Vec<String>,
}
impl Blockchain {
fn new() -> Self {
Blockchain {
chain: vec![Blockchain::create_genesis_block()],
validators: Vec::new(),
current_validators: Vec::new(),
}
}
fn create_genesis_block() -> Block {
Block::new(0, "0", "Genesis Block", "Proof of Place", "Proof of History", None)
}
fn get_latest_block(&self) -> Option<&Block> {
self.chain.last()
}
fn add_validator(&mut self, validator: &str) {
self.validators.push(validator.to_string());
}
fn select_validators(&mut self) -> Vec<String> {
self.current_validators = rand::seq::index::sample(&mut rand::thread_rng(), &self.validators, 3).unwrap();
self.current_validators.clone()
}
fn add_block(&mut self, transaction: Transaction) {
let index = self.chain.len() as u32;
let previous_block = self.get_latest_block().unwrap();
let mut new_block = Block::new(
index,
&previous_block.hash,
&transaction.action_content,
&transaction.generate_proof_of_place(),
&transaction.generate_proof_of_history(),
transaction.zero_knowledge_proof,
);
new_block.calculate_hash();
// Validate the block by current validators
if transaction.validators.iter().all(|v| self.current_validators.contains(v)) {
self.chain.push(new_block);
transaction.pay_reward_to_approver(transaction.love_action_level as f64 * 0.03);
} else {
println!("Block validation failed. Block not added to the chain.");
}
}
}
fn main() {
let mut blockchain = Blockchain::new();
let mut wallets: HashMap<String, Wallet> = HashMap::new();
// Create wallets for municipalities
for municipality in &["Municipality1", "Municipality2", "Municipality3"] {
wallets.insert(municipality.to_string(), Wallet::new(municipality));
}
let users = vec![
("A", "Location1", 8, 2, 4, "Action Content A"),
("B", "Location2", 6, 2, 3, "Action Content B"),
("C", "Location3", 3, 3, 4, "Action Content C"),
("D", "Location4", 10, 3, 2, "Action Content D"),
];
let approvers = vec!["A", "B", "C", "D"];
for (sender_name, location, love_action_level, sender_dimension, receiver_dimension, action_content) in &users {
for (receiver_name, _, _, _, _, _) in &users {
if sender_name != receiver_name {
let approver_name = approvers.choose(&mut rand::thread_rng()).unwrap();
let transaction = Transaction::new(
sender_name,
receiver_name,
location,
*love_action_level,
action_content,
*sender_dimension,
*receiver_dimension,
approver_name,
users.iter().find(|(name, _, _, _, _, _)| name == approver_name).unwrap().3,
);
let validators = blockchain.select_validators();
let love_currency = TOKEN_TYPES.get(&transaction.love_action_level).unwrap_or(&"Unknown");
transaction.transfer_token(love_currency);
blockchain.add_block(transaction);
}
}
}
if let Some(latest_block) = blockchain.get_latest_block() {
println!("Latest Block #{} - Hash: {}", latest_block.index, latest_block.hash);
}
}
いかがであろうか、これで、次元の偏りという評価をすることができるようになった。これをユーザーが閲覧したいとリクエストする度に表示できるようになったことで、次元の偏りを常にチェックできるということだ。