# 2022 Q2(5)  2024.8.2

import numpy as np
from scipy.integrate import dblquad

# 確率密度関数
def pdf(u, v):
    return 1/3 if (u**2 - 2*u*v + v**2 <= 1) else 0

# 期待値 E[U] を計算
E_U, _ = dblquad(lambda v, u: u * pdf(u, v), -1, 1, lambda u: -1, lambda u: 1)
# 期待値 E[V] を計算
E_V, _ = dblquad(lambda v, u: v * pdf(u, v), -1, 1, lambda u: -1, lambda u: 1)

# 期待値 E[U^2] を計算
E_U2, _ = dblquad(lambda v, u: u**2 * pdf(u, v), -1, 1, lambda u: -1, lambda u: 1)
# 期待値 E[V^2] を計算
E_V2, _ = dblquad(lambda v, u: v**2 * pdf(u, v), -1, 1, lambda u: -1, lambda u: 1)

# 分散 Var(U) を計算
Var_U = E_U2 - E_U**2
# 分散 Var(V) を計算
Var_V = E_V2 - E_V**2

# 共分散 Cov(U, V) を計算
Cov_UV, _ = dblquad(lambda v, u: u*v * pdf(u, v), -1, 1, lambda u: -1, lambda u: 1)

# 相関係数 ρ(U, V) を計算
rho_UV = Cov_UV / np.sqrt(Var_U * Var_V)

E_U, E_V, Var_U, Var_V, rho_UV

(0.0, 0.0, 0.27777777931630593, 0.2777565638412289, 0.5000186020617616)

# 2022 Q2(5)  2024.8.2

import numpy as np

# モンテカルロ法の設定
num_points = 10000

# UとVの一様乱数を生成
U = np.random.uniform(-1, 1, num_points)
V = np.random.uniform(-1, 1, num_points)

# 条件 U^2 - 2UV + V^2 <= 1 を満たす点をフィルタリング
condition = U**2 - 2*U*V + V**2 <= 1
U_filtered = U[condition]
V_filtered = V[condition]

# フィルタリングされた点数
num_filtered_points = len(U_filtered)

# 期待値 E[U] と E[V] の計算
E_U = np.mean(U_filtered)
E_V = np.mean(V_filtered)

# 分散 Var(U) と Var(V) の計算
Var_U = np.var(U_filtered, ddof=1)
Var_V = np.var(V_filtered, ddof=1)

# 共分散 Cov(U, V) の計算
Cov_UV = np.cov(U_filtered, V_filtered, ddof=1)[0, 1]

# 相関係数 ρ(U, V) の計算
rho_UV = Cov_UV / np.sqrt(Var_U * Var_V)

E_U, E_V, Var_U, Var_V, rho_UV, num_filtered_points

(-0.0030089627151707833,
 -0.0028658643404494717,
 0.2780688116636205,
 0.2779098545694732,
 0.4835460989080292,
 7488)

#2022 Q2(4) 2024.8.1

import numpy as np
import scipy.integrate as integrate

# 積分の被積分関数を定義
def integrand(v, u):
    return 1/4 if (u**2 - 2*u*v + v**2 <= 1) else 0

# 積分の範囲を定義する関数
def bounds_u():
    return -1, 1

def bounds_v(u):
    return -1, 1

# 確率 P(U^2 - 2UV + V^2 <= 1) を計算
probability, _ = integrate.nquad(integrand, [bounds_v, bounds_u])

probability

0.7500047152195971

#2022 Q2(4) 2024.8.1

import matplotlib.pyplot as plt
import numpy as np

# UとVの範囲を設定
u = np.linspace(-1, 1, 400)
v = np.linspace(-1, 1, 400)
U, V = np.meshgrid(u, v)

# 条件 U^2 - 2UV + V^2 <= 1 を満たす領域を計算
condition = (U**2 - 2*U*V + V**2 <= 1)

# グラフの描画
plt.figure(figsize=(5, 5))
plt.contourf(U, V, condition, levels=[0.5, 1], colors=['lightblue'], alpha=0.5)
plt.title(r'条件 $U^2 - 2UV + V^2 \leq 1$')
plt.xlabel('U')
plt.ylabel('V')
plt.axhline(0, color='gray', lw=0.5)
plt.axvline(0, color='gray', lw=0.5)
plt.grid(True)

# 条件を満たす境界を描画
plt.contour(U, V, condition, levels=[0.5], colors=['blue'])

plt.show()

#2022 Q2(2) 2024.7.30

from sympy import symbols, integrate

# 変数の定義
u, v = symbols('u v')

# 同時累積分布関数の定義
F_uv = (u*v + u + v + 1) / 4

# 周辺累積分布関数 F1(u) と F2(v) の計算
F1_u = integrate(F_uv, (v, -1, 1))
F2_v = integrate(F_uv, (u, -1, 1))

# 周辺確率密度関数 f1(u) と f2(v) の計算
f1_u = F1_u.diff(u)
f2_v = F2_v.diff(v)

# 同時確率密度関数 f(u,v) を求める
f_uv = F_uv.diff(u).diff(v)

# f(u,v) を f1(u) と f2(v) の積として表す
product_f1_f2 = f1_u * f2_v

# 結果の出力
results = {
    'F1_u': F1_u,
    'F2_v': F2_v,
    'f1_u': f1_u,
    'f2_v': f2_v,
    'f_uv': f_uv,
    'product_f1_f2': product_f1_f2
}

results

{'F1_u': u/2 + 1/2,
 'F2_v': v/2 + 1/2,
 'f1_u': 1/2,
 'f2_v': 1/2,
 'f_uv': 1/4,
 'product_f1_f2': 1/4}

#2022 Q2(3) 2024.7.31

from sympy import symbols, pi
import numpy as np
from scipy.integrate import quad

# 符号変数の定義
u, v = symbols('u v')

# f(u,v) の定義
f_uv_value = 1/4

# 条件を満たす範囲でのf(u,v)（数値積分用）
def integrand(v, u):
    if u**2 + v**2 <= 1:
        return f_uv_value
    else:
        return 0

# uに関しての積分
def integrate_u(u):
    return quad(integrand, -1, 1, args=(u))[0]

# 数値積分による評価
probability_numeric = quad(integrate_u, -1, 1)[0]

# 手計算による値 (π/4) の計算
manual_calculation_value = pi / 4

# 結果の出力
print(f"数値積分による確率: {probability_numeric}\n")
print(f"手計算による値 (π/4): {manual_calculation_value.evalf()}\n")

数値積分による確率: 0.7855319594076084

手計算による値 (π/4): 0.785398163397448

#2022 Q2(3) 2024.7.31

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# u, vの範囲と値を定義
u = np.linspace(-1, 1, 100)
v = np.linspace(-1, 1, 100)
U, V = np.meshgrid(u, v)

# f(u,v)の値を計算
f_uv_value = 1/4
F = np.where(U**2 + V**2 <= 1, f_uv_value, 0)

# 3Dプロットを作成
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.plot_surface(U, V, F, cmap='viridis')
ax.set_xlabel('U')
ax.set_ylabel('V')
ax.set_zlabel('f(u,v)')
ax.set_zlim(0, 1)  # z軸の範囲を設定
ax.set_title('領域 U^2 + V^2 <= 1 における f(u,v) の3Dプロット')
plt.show()

#2022 Q2(1)  2024.7.29

from sympy import symbols, integrate

# 変数の定義
u, v = symbols('u v')

# 同時累積分布関数の定義
F_uv = (u*v + u + v + 1) / 4

# 周辺累積分布関数 F1(u) と F2(v) の計算
F1_u = integrate(F_uv, (v, -1, 1))
F2_v = integrate(F_uv, (u, -1, 1))

F1_u, F2_v

(u/2 + 1/2, v/2 + 1/2)

#2022 Q2(1)  2024.7.29

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# 同時累積分布関数 F(u, v) を定義
def F(u, v):
    return (u * v + u + v + 1) / 4

# u, v の範囲を設定
u = np.linspace(-1, 1, 100)
v = np.linspace(-1, 1, 100)
u, v = np.meshgrid(u, v)
z = F(u, v)

# 3Dプロットの作成
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.plot_surface(u, v, z, cmap='viridis')

# グラフのラベル
ax.set_xlabel('U')
ax.set_ylabel('V')
ax.set_zlabel('F(U, V)')
ax.set_title('同時累積分布関数 F(U, V)')

plt.show()

#2022 Q1(4)  2024.7.28

# 定数
total_points = 16
PA = 3 / 4
PB = 3 / 4
PC = 3 / 4
PAB = 9 / 16
PAC = 9 / 16
PBC = 9 / 16

# 結果を格納するリスト
valid_probabilities = []

# 最小値と最大値を取るときの組み合わせを格納する変数
min_combination = None
max_combination = None
min_value = float('inf')
max_value = float('-inf')

# 各エリアの点数の範囲を狭める
for n1 in range(total_points // 3 + 1):
    for n2 in range((total_points - 3 * n1) // 3 + 1):
        for n3 in range(total_points - 3 * n1 - 3 * n2 + 1):
            n4 = total_points - 3 * n1 - 3 * n2 - n3
            if n4 < 0:
                continue

            calc_PA = (n1 + 2 * n2 + n4) / total_points
            calc_PB = (n1 + 2 * n2 + n4) / total_points
            calc_PC = (n1 + 2 * n2 + n4) / total_points
            calc_PAB = (n2 + n4) / total_points
            calc_PAC = (n2 + n4) / total_points
            calc_PBC = (n2 + n4) / total_points

            # 条件を満たすか確認
            if (abs(calc_PA - PA) < 1e-9 and 
                abs(calc_PB - PB) < 1e-9 and 
                abs(calc_PC - PC) < 1e-9 and 
                abs(calc_PAB - PAB) < 1e-9 and 
                abs(calc_PAC - PAC) < 1e-9 and 
                abs(calc_PBC - PBC) < 1e-9):
                
                current_PABC = n4 / total_points
                valid_probabilities.append(current_PABC)
                
                if current_PABC < min_value:
                    min_value = current_PABC
                    min_combination = (n1, n2, n3, n4)
                
                if current_PABC > max_value:
                    max_value = current_PABC
                    max_combination = (n1, n2, n3, n4)

# 最小値と最大値を表示
min_PABC = min_value if valid_probabilities else None
max_PABC = max_value if valid_probabilities else None

# 結果の表示
print(f"最小値: {min_PABC}")
print(f"最大値: {max_PABC}")
print(f"最小値を取るときのN1, N2, N3, N4: {min_combination}")
print(f"最大値を取るときのN1, N2, N3, N4: {max_combination}")

最小値: 0.375
最大値: 0.4375
最小値を取るときのN1, N2, N3, N4: (0, 3, 1, 6)
最大値を取るときのN1, N2, N3, N4: (1, 2, 0, 7)

### 2022 Q1(3)   2024.7.27

import itertools

def generate_combinations(n, k):
    base_list = [1] * k + [0] * (n - k)
    all_combinations = set(itertools.permutations(base_list))
    return list(all_combinations)

def calculate_intersection(A, B, C):
    return np.mean(np.array(A) & np.array(B) & np.array(C))

def find_min_max_intersection(n, k):
    all_combinations = generate_combinations(n, k)
    min_intersection = 1.0
    max_intersection = 0.0

    for A in all_combinations:
        for B in all_combinations:
            for C in all_combinations:
                intersection_ratio = calculate_intersection(A, B, C)
                if intersection_ratio < min_intersection:
                    min_intersection = intersection_ratio
                if intersection_ratio > max_intersection:
                    max_intersection = intersection_ratio

    return min_intersection, max_intersection

# パラメータを設定
n = 8
k = 6

# 最小値と最大値を計算
min_intersection, max_intersection = find_min_max_intersection(n, k)

min_intersection, max_intersection

(0.25, 0.75)

### 2022 Q1(1)   2024.7.26

import numpy as np

# シミュレーションの回数
num_simulations = 1000000

# 与えられた確率
prob = 3/4

# 事象 A, B, C をシミュレーション
A = np.random.rand(num_simulations) < prob
B = np.random.rand(num_simulations) < prob
C = np.random.rand(num_simulations) < prob

# 交差確率の計算
P_A_and_B = np.mean(A & B)
P_A_and_B_and_C = np.mean(A & B & C)

P_A_and_B, P_A_and_B_and_C

(0.56311, 0.422594)

#検算
9/16,27/64

(0.5625, 0.421875)

### 2022 Q1(2)   2024.7.26

import numpy as np

def simulate_overlap_with_fixed_true(correlation):
    P_A = 3/4
    P_B = 3/4
    num_elements = 1000
    num_true_A = int(P_A * num_elements)
    num_true_B = int(P_B * num_elements)

    # A と B の配列を生成し、3/4がtrueになるように設定
    A = np.zeros(num_elements, dtype=bool)
    A[:num_true_A] = True
    np.random.shuffle(A)

    B = np.zeros(num_elements, dtype=bool)
    B[:num_true_B] = True
    np.random.shuffle(B)

    if correlation == 'positive':
        # 正の相関を持たせるために、スワップを行う
        A1_B0_indices = np.where(A & ~B)[0]
        A0_B1_indices = np.where(~A & B)[0]

        min_len = min(len(A1_B0_indices), len(A0_B1_indices))
        for i in range(min_len):
            B[A1_B0_indices[i]], B[A0_B1_indices[i]] = B[A0_B1_indices[i]], B[A1_B0_indices[i]]

    elif correlation == 'negative':
        # 負の相関を持たせるために、スワップを行う
        A1_B1_indices = np.where(A & B)[0]
        A0_B0_indices = np.where(~A & ~B)[0]

        min_len = min(len(A1_B1_indices), len(A0_B0_indices))
        for i in range(min_len):
            B[A1_B1_indices[i]], B[A0_B0_indices[i]] = B[A0_B0_indices[i]], B[A1_B1_indices[i]]

    else:
        raise ValueError("Invalid correlation type")

    # 重なりの割合を計算
    overlap_ratio = np.mean(A & B)

    return overlap_ratio

# 正の相関の場合
overlap_positive = simulate_overlap_with_fixed_true('positive')

# 負の相関の場合
overlap_negative = simulate_overlap_with_fixed_true('negative')

overlap_positive, overlap_negative

(0.75, 0.5)