diff --git a/because/causality/cdisc.py b/because/causality/cdisc.py index 7b048f7..dea6d22 100644 --- a/because/causality/cdisc.py +++ b/because/causality/cdisc.py @@ -353,11 +353,18 @@ def discover(ps, varNames=None, maxLevel=2, power=5, sensitivity=5, verbosity=2) v1, v2 = link linkR = (v2, v1) if (ps.isCategorical(v1) or ps.cardinality(v1) == 2) and (ps.isCategorical(v2) or ps.cardinality(v2) == 2): - # Both variables are either categorical or binary. Use differential entropy - de = dirDE(ps, v1, v2, verbosity=verbosity) - vprint(4, verbosity, 'cdisc.discover: Differential Entropy for', link, 'is', de) - dirDict[link] = de - dirDict[linkR] = -de + # Both variables are either categorical or binary. Use UCM via testDirection + adj1 = adjacencies[v1] + adj2 = adjacencies[v2] + + adj = list(set(adj1 + adj2)) + adj.remove(v1) + adj.remove(v2) + # adj now contains the set of adjacencies to either v1 or v2, without v1 or v2 + dir = testDirection(ps, v1, v2, [], power, maxLevel=maxLevel, verbosity=verbosity) + vprint(4, verbosity, 'cdisc.discover: Final direction for', link, 'is', dir) + dirDict[link] = dir + dirDict[linkR] = -dir elif (ps.isCategorical(v1) or ps.cardinality(v1) == 2) or (ps.isCategorical(v2) or ps.cardinality(v2) == 2): # We have no method for this case dirDict[link] = 0 diff --git a/because/probability/prob.py b/because/probability/prob.py index 681fbcc..02cf1f7 100644 --- a/because/probability/prob.py +++ b/because/probability/prob.py @@ -15,6 +15,7 @@ from sklearn.ensemble import RandomForestClassifier from because.probability import direction from because.probability.standardiz import standardize +from because.probability.ucm import ucm DEBUG = False @@ -1829,14 +1830,14 @@ def testDirection(self, rvA, rvB, givenSpecs=[], power=None, N_train=2000): else: # Unconditional. # Standardize the data. - if self.cardinality(rvA) > 2: + if self.cardinality(rvA) > 2 and not self.isCategorical(rvA): standA = self.standCache.get(rvA, None) if standA is None: standA = standardize(self.ds[rvA]) self.standCache[rvA] = standA else: standA = self.ds[rvA] - if self.cardinality(rvB) > 2: + if self.cardinality(rvB) > 2 and not self.isCategorical(rvB): standB = self.standCache.get(rvB, None) if standB is None: standB = standardize(self.ds[rvB]) @@ -1844,8 +1845,19 @@ def testDirection(self, rvA, rvB, givenSpecs=[], power=None, N_train=2000): else: standB = self.ds[rvB] # Call the direction module with standardized data. - rho = direction.test_direction(standA, standB, power, N_train) - # Add result to cache + # Use UC model for categorical and binary data. + if (self.isCategorical(rvA) or (self.isDiscrete(rvA) and self.cardinality(rvA) < 3)) \ + and (self.isCategorical(rvB) or (self.isDiscrete(rvB) and self.cardinality(rvB) < 3)): + if rvA in self.stringMapR.keys() and rvB in self.stringMapR.keys(): + # For readability with testing + rho, identifiable = ucm.uniform_channel_test(standA, standB, AMap=self.stringMapR[rvA], BMap=self.stringMapR[rvB]) + else: + rho, identifiable = ucm.uniform_channel_test(standA, standB) + else: + # Use ANM test + rho = direction.test_direction(standA, standB, power, N_train) + + # Add result to cache self.dirCache[cacheKey] = rho # Add reverse result to cache, with reversed rho reverseKey = (rvB, rvA, tuple(givenSpecs), power) diff --git a/because/probability/ucm/__init__.py b/because/probability/ucm/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/because/probability/ucm/categTestStats.py b/because/probability/ucm/categTestStats.py new file mode 100644 index 0000000..ee5f19f --- /dev/null +++ b/because/probability/ucm/categTestStats.py @@ -0,0 +1,218 @@ +import pandas as pd +import numpy as np +import math +import scipy.stats as stats +''' +Testing file for developing UCM implementation. +''' + +# df = pd.read_csv("models/trinaryCateg.csv") +# df = pd.read_csv("models/categTest1.csv") +df = pd.read_csv("models/M1C.csv") + +n = len(df) +print(f"\n Number of entries: {len(df)}") + +x_size = 2 +y_size = 2 + +# ---- Joint Probability +print("\n\tJoint Probability Table") +joint_prob = df.value_counts(["A", "B"]).unstack() +joint_rows = [joint_prob.iloc[i].to_list() for i in range(x_size)] +print(joint_prob) + +# ---- Y|X Conditional Probability (Causal Direction) +cond_y = (df.groupby('A')['B'].value_counts() / df.groupby('A')['B'].count()).unstack().T +cond_y_trunc = cond_y.round(3) # truncated probabilities +y_rows = [cond_y_trunc.iloc[i].to_list() for i in range(x_size)] # each row is prob y given X = i +y_sort = [sorted(y_rows[i], reverse=True) for i in range(x_size)] +# +print(f"\n\tProbability of Y given X: \n {cond_y}") +print(f"\n\t Rows of Y|X cond prob: \n") +print(*y_rows, sep='\n') +print(f"\n\t Sorted rows: \n") +print(*y_sort, sep='\n') + +# ---- X|Y Conditional Probability (NonCausal Direction) +cond_x = (df.groupby('B')['A'].value_counts() / df.groupby('B')['A'].count()).unstack() +cond_x_trunc = cond_x.round(3) # truncated probabilities +x_rows = [cond_x_trunc.iloc[i].to_list() for i in range(y_size)] +x_sort = [sorted(x_rows[i], reverse=True) for i in range(y_size)] + +print(f"\n\tProbability of X given Y: \n{cond_x}") +print(f"\n\t Rows of X|Y cond prob: \n") +print(*x_rows, sep='\n') +print(f"\n\t Sorted rows: \n") +print(*x_sort, sep='\n') + +# ---- Calculate MLE for the rows +# Test one: calculate MLE for y given x=1. +# Entry 1: N(Y=1|X=1) / N(X=1) +print("\n\tContingency table") +cont_table = df.value_counts(['B', 'A']).unstack() +print(cont_table) +cond_y = (df.groupby('A')['B'].value_counts() / df.groupby('A')['B'].count()).unstack() +x_row_count = df['A'].value_counts() # this returns the sum of each X row +y_col_count = df['B'].value_counts() # this returns the sum of each Y column + +row_count = [cont_table.iloc[i].to_list() for i in range(x_size)] +row_count_sort = [sorted(row_count[i], reverse=True) for i in range(x_size)] +print(f"\n\tSorted rows:") +print(*row_count_sort, sep="\n") + +# --- Calculating the MLE for the distribution of Y given X. +# --- Use the MLE to determine how different each row is from the predicted distribution (for a uniform channel) + +# Sort row counts by largest category in each row to smallest. +t = [[row_count_sort[i][j] for i in range(x_size)] for j in range(y_size)] +N_x = [sum(row) for row in row_count] +print(t) +print(N_x) + +expected_xy = [[(t[y][x], N_x[x]) for x in range(x_size)] for y in range(y_size)] +print(f"Expected xy: {expected_xy}") +# p = [(row_count_sort[x][y]*N_x[x]/n) for y in range(y_size) for x in range(x_size)] +# print(p) +# # mle = sum(t)/len(df) +mle = [sum(i) / n for i in t] +# # mle = expected_xy/n +print(f"\n\tMLE: {mle}") + + +# New test: try to do the entropy calculation for each row. Compare to the entropy of MLE. +def calc_entropy(row): + entropy = -1 * sum(elem * np.log(elem+0.000001) for elem in row) + return round(entropy,4) + + +mle_entropy = calc_entropy(mle) +observed_entropy = [calc_entropy(row) for row in y_rows] +print(f"MLE: {mle} \n\t Entropy: {mle_entropy}") +print(f"Observed: {y_rows} \n\t Entropy: {observed_entropy}") + +print(calc_entropy([1 / 3, 1 / 3, 1 / 3])) +print(calc_entropy([0, 0, 1])) + +# # Calculate expected value for each row: using the MLE just distribute each row +# exp_xy_sorted = [[N_x[i] * mle[j] for j in range(y_size)] for i in range(x_size)] +# print("\n\tExpected sorted rows:") +# print(*exp_xy_sorted, sep="\n") +# +# # Compare sorted rows to sorted expected rows +# # p = [(exp_xy_sorted[x][y], row_count_sort[x][y]) for x in range(x_size) for y in range(y_size)] +# pre_g = [row_count_sort[x][y]*np.log(row_count_sort[x][y]/exp_xy_sorted[x][y]) for x in range(x_size) for y in range(y_size)] +# g_squared = 2*sum(pre_g) +# print(f"\n\tG-squared value: {g_squared}") +# +# # Convert to a real p value +# dof = (x_size-1) * (y_size-1) +# print(f"p-value: {round(1-stats.chi2.cdf(g_squared, df=dof), 4)}") +# + +# # Repeat for non-causal direction +# print("\n\tContingency table (Y->X)") +# +# cont_table = df.value_counts(['Y', 'X']).unstack() +# print(cont_table) +# row_count = [cont_table.iloc[i].to_list() for i in range(y_size)] +# row_count_sort = [sorted(row_count[i], reverse=True) for i in range(y_size)] +# +# t = [[row_count_sort[i][j] for i in range(y_size)] for j in range(x_size)] +# N_y = [sum(row) for row in row_count] +# expected_yx = [[(t[x][y], N_y[y]) for y in range(y_size)] for x in range(x_size)] +# mle = [sum(i)/n for i in t] +# exp_yx_sorted = [[N_y[i] * mle[j] for j in range(x_size)] for i in range(y_size)] +# print(*exp_yx_sorted, sep="\n") +# pre_g = [row_count_sort[y][x]*np.log(row_count_sort[y][x]/exp_yx_sorted[y][x]) for y in range(y_size) for x in range(x_size)] +# print("COMPARE:", [(row_count_sort[y][x], exp_yx_sorted[y][x]) for y in range(y_size) for x in range(x_size)]) +# g_squared = 2*sum(pre_g) +# print(f"g-squared: {g_squared}") +# dof = (x_size-1) * (y_size-1) +# print(f"p-value: {1-stats.chi2.cdf(g_squared, df=dof)}") + + +# # Obtain expected value and observed value as pairs +# oe_pairs = [(t[i][j], expected_xy[i]) for i in range(y_size) for j in range(x_size)] +# print(f"Observed/Expected pairs: {oe_pairs}") +# print("1", [(t[i][j]/expected_xy[i]) for i in range(y_size) for j in range(x_size)]) +# print("2", [np.log(t[i][j]/expected_xy[i]) for i in range(y_size) for j in range(x_size)]) +# print("3", [t[i][j] * np.log(t[i][j]/expected_xy[i]) for i in range(y_size) for j in range(x_size)]) + +# Do G-test to obtain p value +# w = [t[i][j] * np.log(t[i][j]/expected_xy[i]) for i in range(y_size) for j in range(x_size)] +# print(w) +# g_squared = 2*sum(w) +# print(g_squared) +# dof = (x_size-1) * (y_size-1) + +# print(f"p value: {1-stats.chi2.cdf(g_squared, df=dof)}") + + +# --- Compare MLE to row computations +print("\n\tTotal difference from sorted rows to MLE") +for i in range(x_size): + # Get % difference from MLE + print(f"\tRow {i}:") + s = [round(mle[j] - y_sort[i][j], 4) for j in range(y_size)] + print(s) + +print("\n\tPercent difference from sorted rows to MLE") +for i in range(x_size): + # Get % difference from MLE + print(f"\tRow {i}:") + s = [round((mle[j] - y_sort[i][j]) / mle[j], 4) for j in range(y_size)] + print(s) + +# --- Repeat for Y->X direction +print("\n----- Y -> X -----") +print("\n\tContingency table") +cont_table = df.value_counts(['B', 'A']).unstack() +print(cont_table) +row_count = [cont_table.iloc[i].to_list() for i in range(y_size)] +row_count_sort = [sorted(row_count[i], reverse=True) for i in range(y_size)] +print(row_count_sort) + +t = [[row_count_sort[i][j] for i in range(y_size)] for j in range(x_size)] +print(t) +mle = [sum(i) / n for i in t] +print(mle) + +mle_entropy = calc_entropy(mle) +observed_entropy = [calc_entropy(row) for row in x_rows] +print(f"MLE: {mle} \n\t Entropy: {mle_entropy}") +print(f"Observed: {x_rows} \n\t Entropy: {observed_entropy}") + +expected_yx = [sum(i) / y_size for i in t] +print(f"Expected yx vals: {expected_yx}") + +mle = [sum(i) / n for i in t] +print(f"\n\tMLE: {mle}") +# +# # Obtain expected value and observed value as pairs +# oe_pairs = [(t[i][j], expected_yx[i]) for i in range(x_size) for j in range(y_size)] +# print(f"Observed/Expected pairs: {oe_pairs}") +# +# # Do G-test to obtain p value +# w = [t[i][j] * np.log(t[i][j]/expected_yx[i]) for i in range(x_size) for j in range(y_size)] +# g_squared = 2*sum(w) +# print(g_squared) +# dof = (x_size-1) * (y_size-1) +# +# print(f"p value: {1-stats.chi2.cdf(g_squared, df=dof)}") + +# --- Compare MLE to row computations +print("\n\tTotal difference from sorted rows to MLE") +for i in range(y_size): + # Get % difference from MLE + print(f"\tRow {i}:") + s = [round(mle[j] - x_sort[i][j], 4) for j in range(x_size)] + print(s) + +print("\n\tPercent difference from sorted rows to MLE") +for i in range(y_size): + # Get % difference from MLE + print(f"\tRow {i}:") + s = [round((mle[j] - x_sort[i][j]) / mle[j], 4) for j in range(x_size)] + print(s) + diff --git a/because/probability/ucm/llcp_pairs.py b/because/probability/ucm/llcp_pairs.py new file mode 100644 index 0000000..bba0cd7 --- /dev/null +++ b/because/probability/ucm/llcp_pairs.py @@ -0,0 +1,34 @@ +import pandas as pd +import numpy as np +from because.probability.ucm import ucm +from because.synth import Reader +''' +UCM testing on CDC dataset. +Tests all pairs of directions present in the categorical variables. +I recommend saving output to a text file on run for analysis: + python3 llcp_pairs.py > output.txt +Computing with full dataset vs a sample will produce somewhat different results. +''' + +df = pd.read_csv("models/llcp.csv") + +ds = Reader("models/llcp.csv") +# ds = Reader("models/llcp.csv", limit=10000) + +varNames = ds.getSeriesNames() +numeric = ['age', 'weight', 'height', 'bmi'] +discreteNum = ['ageGroup', 'income', 'sleephours', 'drinks'] +catVars = [i for i in varNames if i not in (numeric+discreteNum)] + +for i in range(len(catVars)): + # print(f'\n\tvariable: {catVars[i]}, length: {len(set(ds.getSeries(catVars[i])))} \n {set(ds.getSeries(catVars[i]))}') + for j in range(i + 1, len(catVars)): + A = np.array(df[catVars[i]].tolist()) + B = np.array(df[catVars[j]].tolist()) + print(f"\n=============\n\ttesting: {catVars[i]} -> {catVars[j]}") + rho, identifiable = ucm.uniform_channel_test(A, B) + if identifiable: + if rho > 0: + print(f"Implied Direction: {catVars[i]} -> {catVars[j]}") + else: + print(f"Implied Direction: {catVars[j]} -> {catVars[i]}") diff --git a/because/probability/ucm/llcp_ucm.ipynb b/because/probability/ucm/llcp_ucm.ipynb new file mode 100644 index 0000000..41fbee2 --- /dev/null +++ b/because/probability/ucm/llcp_ucm.ipynb @@ -0,0 +1,701 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-09T02:21:47.196610Z", + "start_time": "2023-08-09T02:21:41.683226Z" + } + }, + "outputs": [], + "source": [ + "from because.synth import Reader\n", + "from because.probability import prob\n", + "from because.causality import cdisc\n", + "from because.visualization import cmodel" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Read in dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-09T02:22:03.867885Z", + "start_time": "2023-08-09T02:21:47.202445Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "getData: 290759 records read.\n" + ] + } + ], + "source": [ + "filename = \"models/llcp.csv\"\n", + "# ds = Reader(filename, limit=10000)\n", + "ds = Reader(filename)\n", + "varNames = ds.getSeriesNames()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Mark variable types" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-09T02:22:03.912548Z", + "start_time": "2023-08-09T02:22:03.873912Z" + } + }, + "outputs": [], + "source": [ + "numeric = ['age', 'weight', 'height', 'bmi']\n", + "discreteNum = ['ageGroup', 'income', 'sleephours', 'drinks']\n", + "catVars = [i for i in varNames if i not in (numeric+discreteNum)]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-09T02:22:04.335023Z", + "start_time": "2023-08-09T02:22:04.323277Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": "['gender',\n 'genhealth',\n 'asthma_ever',\n 'asthma',\n 'skincancer',\n 'othercancer',\n 'copd',\n 'arthritis',\n 'depression',\n 'kidneydis',\n 'diabetes',\n 'maritaldetail',\n 'married',\n 'education',\n 'veteran',\n 'state',\n 'childcnt',\n 'employment',\n 'smokertype',\n 'physicalactivity',\n 'insurance',\n 'checkup',\n 'nohospitalcost',\n 'bmicat']" + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "catVars" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create a probspace with the categorical variables marked as such (important for some to be treated as categorical and not discrete numeric)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-09T02:22:08.944572Z", + "start_time": "2023-08-09T02:22:04.379477Z" + } + }, + "outputs": [], + "source": [ + "ps = prob.ProbSpace(ds.varData, categorical=catVars)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Throwing all variables in is a bad idea; need to isolate categorical." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-09T02:22:08.956760Z", + "start_time": "2023-08-09T02:22:08.945397Z" + } + }, + "outputs": [], + "source": [ + "# cdisc.discover(ps)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Trying to throw all the cat variables in is still far too much; better off doing a select number at a time. Limiting the read in to initialize ds helps a little with speed, but seems to throw some strange errors with dependency. Removing the limit seems to remove the errors." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-09T02:22:08.990361Z", + "start_time": "2023-08-09T02:22:08.964716Z" + } + }, + "outputs": [], + "source": [ + "# cdisc.discover(ps, varNames=catVars)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Test direction appropriately calls UCM for the two variables, returns rho value and identifiability." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-09T02:22:09.863013Z", + "start_time": "2023-08-09T02:22:08.975442Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\tTesting gender -> genhealth direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 0.0 \n", + "Backward:0.0\n", + "Rho-value: 0.0\n", + "identifiable: False\n" + ] + }, + { + "data": { + "text/plain": "0.0" + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ps.testDirection('gender', 'genhealth')" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-09T02:22:10.594721Z", + "start_time": "2023-08-09T02:22:09.900377Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\tTesting gender -> arthritis direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 0.0 \n", + "Backward:0.0\n", + "Rho-value: 0.0\n", + "identifiable: False\n" + ] + }, + { + "data": { + "text/plain": "0.0" + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ps.testDirection('gender', 'arthritis')" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-09T02:22:11.037539Z", + "start_time": "2023-08-09T02:22:10.678301Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\tTesting arthritis -> ageGroup direction\n", + "Using ANM test...\n" + ] + }, + { + "data": { + "text/plain": "0.09424524027970939" + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ps.testDirection('arthritis', 'ageGroup')" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-09T02:22:11.349817Z", + "start_time": "2023-08-09T02:22:11.044607Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\tTesting genhealth -> ageGroup direction\n", + "Using ANM test...\n" + ] + }, + { + "data": { + "text/plain": "0.007960454624064564" + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ps.testDirection('genhealth', 'ageGroup')" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-09T02:22:43.109538Z", + "start_time": "2023-08-09T02:22:11.360418Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " cmodel.show: Performing Discovery.\n", + "Pass 1 of 3\n", + " ageGroup -- gender are independent\n", + "Pass 2 of 3\n", + " ageGroup -- bmicat is blocked by ('arthritis',)\n", + " conflicts resolved: [(0.13255512897523625, ('ageGroup', 'depression', ('bmicat',))), (0.2947662905273777, ('ageGroup', 'bmicat', ('depression',))), (0.3125754111577419, ('bmicat', 'depression', ('ageGroup',)))]\n", + " ageGroup -- depression is blocked by ('bmicat',)\n", + " conflicts resolved: [(0.3113418851192863, ('ageGroup', 'bmicat', ('gender',))), (0.347718335927517, ('bmicat', 'gender', ('ageGroup',)))]\n", + " ageGroup -- bmicat is blocked by ('gender',)\n", + " ageGroup -- depression is blocked by ('gender',)\n", + " arthritis -- gender is blocked by ('ageGroup',)\n", + " conflicts resolved: [(0.3625660001978295, ('bmicat', 'gender', ('arthritis',))), (0.4314761560642067, ('arthritis', 'gender', ('bmicat',)))]\n", + " bmicat -- gender is blocked by ('arthritis',)\n", + " arthritis -- gender is blocked by ('depression',)\n", + " bmicat -- depression is blocked by ('arthritis',)\n", + " conflicts resolved: [(0.3198075038027801, ('bmicat', 'gender', ('depression',))), (0.3315620422658016, ('bmicat', 'depression', ('gender',)))]\n", + " bmicat -- gender is blocked by ('depression',)\n", + "Pass 3 of 3\n", + "Detecting valid links.\n", + "\n", + "\tTesting arthritis -> bmicat direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 0.0 \n", + "Backward:0.0\n", + "Rho-value: 0.0\n", + "identifiable: False\n", + " cdisc.testDirection: best combo for( arthritis , bmicat ) = None , rho = 0\n", + " cdisc.testDirection: avgRho = 0.0\n", + "\n", + "\tTesting arthritis -> depression direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 0.0 \n", + "Backward:0.0\n", + "Rho-value: 0.0\n", + "identifiable: False\n", + " cdisc.testDirection: best combo for( arthritis , depression ) = None , rho = 0\n", + " cdisc.testDirection: avgRho = 0.0\n", + "\n", + "\tTesting depression -> gender direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 0.0 \n", + "Backward:0.0\n", + "Rho-value: 0.0\n", + "identifiable: False\n", + " cdisc.testDirection: best combo for( depression , gender ) = None , rho = 0\n", + " cdisc.testDirection: avgRho = 0.0\n", + "triangles = [('arthritis', 'ageGroup', 'bmicat'), ('arthritis', 'ageGroup', 'depression'), ('arthritis', 'bmicat', 'depression'), ('depression', 'arthritis', 'gender')]\n", + " cdisc.discover: found causal link: arthritis -> ageGroup ( 0 )\n", + " cdisc.discover: found causal link: arthritis -> bmicat ( 0.2 )\n", + " cdisc.discover: found causal link: depression -> arthritis ( -0.0 )\n", + " cdisc.discover: found causal link: depression -> gender ( 0.2 )\n", + " cDisc.discover: Duration = 30.1\n", + " cmodel.show: Analyzing Graph Relations.\n", + " cmodel.show: Producing graphics.\n", + "Map = \n", + " arthritis --> ageGroup ( 0 )\n", + " arthritis --> bmicat ( 0.2 )\n", + " depression --> arthritis ( -0.0 )\n", + " depression --> gender ( 0.2 )\n", + " cmodel.show: Elapsed = 31.0\n" + ] + }, + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cmodel.show(probspace=ps, targetSpec=['arthritis', 'ageGroup', 'gender', 'bmicat', 'depression'], edgeLabels='rho' )\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Code chunk below throws an error described earlier regardless of limit; doesn't like some interaction with dependence testing?" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-09T02:23:30.012420Z", + "start_time": "2023-08-09T02:22:43.119499Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " cmodel.show: Performing Discovery.\n", + "Pass 1 of 3\n", + " gender -- genhealth are independent\n", + "Pass 2 of 3\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Library/Python/3.9/site-packages/scipy/stats/_distn_infrastructure.py:2176: RuntimeWarning: divide by zero encountered in divide\n", + " x = np.asarray((x - loc)/scale, dtype=dtyp)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7435275458130514\n", + "0.7514361449874603\n", + " conflicts resolved: [(0.18297862754345923, ('drinks', 'physicalactivity', ('genhealth',))), (0.3034432971444816, ('drinks', 'genhealth', ('physicalactivity',)))]\n", + " drinks -- physicalactivity is blocked by ('genhealth',)\n", + "Pass 3 of 3\n" + ] + }, + { + "ename": "AttributeError", + "evalue": "'NoneType' object has no attribute 'N'", + "output_type": "error", + "traceback": [ + "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m", + "\u001B[0;31mValueError\u001B[0m Traceback (most recent call last)", + "File \u001B[0;32m~/Documents/Causality/Because/because/probability/prob.py:1947\u001B[0m, in \u001B[0;36mProbSpace.dependence\u001B[0;34m(self, rv1, rv2, givenSpecs, power, raw, seed, num_f, num_f2, sensitivity, dMethod)\u001B[0m\n\u001B[1;32m 1946\u001B[0m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[0;32m-> 1947\u001B[0m (Cxy_z, Sta, p) \u001B[38;5;241m=\u001B[39m \u001B[43mRCoT\u001B[49m\u001B[43m(\u001B[49m\u001B[43mx\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43my\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mz\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mnum_f\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mnum_f\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mnum_f2\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mnum_f2\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mseed\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mseed\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 1948\u001B[0m \u001B[38;5;28;01mexcept\u001B[39;00m:\n", + "File \u001B[0;32m/Library/Python/3.9/site-packages/because/probability/rcot/RCoT.py:282\u001B[0m, in \u001B[0;36mRCoT\u001B[0;34m(x, y, z, approx, num_f, num_f2, r, seed)\u001B[0m\n\u001B[1;32m 281\u001B[0m w1 \u001B[38;5;241m=\u001B[39m w\n\u001B[0;32m--> 282\u001B[0m p \u001B[38;5;241m=\u001B[39m \u001B[38;5;241m1\u001B[39m \u001B[38;5;241m-\u001B[39m \u001B[43mlpb4\u001B[49m\u001B[43m(\u001B[49m\u001B[43mnp\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43marray\u001B[49m\u001B[43m(\u001B[49m\u001B[43mw1\u001B[49m\u001B[43m)\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mSta\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 283\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m(p\u001B[38;5;241m==\u001B[39m\u001B[38;5;28;01mNone\u001B[39;00m \u001B[38;5;129;01mor\u001B[39;00m np\u001B[38;5;241m.\u001B[39misnan(p)):\n", + "File \u001B[0;32m/Library/Python/3.9/site-packages/because/probability/rcot/lpb4.py:97\u001B[0m, in \u001B[0;36mlpb4\u001B[0;34m(coeff, x)\u001B[0m\n\u001B[1;32m 96\u001B[0m bisect_tol \u001B[38;5;241m=\u001B[39m \u001B[38;5;241m1e-6\u001B[39m\n\u001B[0;32m---> 97\u001B[0m lambdatilde_p \u001B[38;5;241m=\u001B[39m \u001B[43mget_lambdatilde_p\u001B[49m\u001B[43m(\u001B[49m\u001B[43mlambdatilde_1\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mp\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mmoment_vec\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mbisect_tol\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 98\u001B[0m \u001B[38;5;66;03m# print(\"lambdatilde_p \",lambdatilde_p )\u001B[39;00m\n", + "File \u001B[0;32m/Library/Python/3.9/site-packages/because/probability/rcot/lpb4.py:196\u001B[0m, in \u001B[0;36mget_lambdatilde_p\u001B[0;34m(lambdatilde_1, p, moment_vec, bisect_tol)\u001B[0m\n\u001B[1;32m 192\u001B[0m \u001B[38;5;28;01mfor\u001B[39;00m i \u001B[38;5;129;01min\u001B[39;00m \u001B[38;5;28mrange\u001B[39m(\u001B[38;5;241m1\u001B[39m,p):\n\u001B[1;32m 193\u001B[0m \u001B[38;5;66;03m#TODO: uniroot, root\u001B[39;00m\n\u001B[1;32m 194\u001B[0m \u001B[38;5;66;03m# print(i) \u001B[39;00m\n\u001B[1;32m 195\u001B[0m \u001B[38;5;66;03m# print(\"lambdatilde_vec[i-1]: \", lambdatilde_vec[i-1])\u001B[39;00m\n\u001B[0;32m--> 196\u001B[0m lambdatilde_vec[i] \u001B[38;5;241m=\u001B[39m \u001B[43muniroot\u001B[49m\u001B[43m(\u001B[49m\u001B[43mdet_deltamat_n\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43m[\u001B[49m\u001B[38;5;241;43m0\u001B[39;49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mlambdatilde_vec\u001B[49m\u001B[43m[\u001B[49m\u001B[43mi\u001B[49m\u001B[38;5;241;43m-\u001B[39;49m\u001B[38;5;241;43m1\u001B[39;49m\u001B[43m]\u001B[49m\u001B[43m]\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mm_vec\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mmoment_vec\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mN\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mi\u001B[49m\u001B[38;5;241;43m+\u001B[39;49m\u001B[38;5;241;43m1\u001B[39;49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mtol\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mbisect_tol\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 197\u001B[0m lambdatilde_p \u001B[38;5;241m=\u001B[39m lambdatilde_vec[p\u001B[38;5;241m-\u001B[39m\u001B[38;5;241m1\u001B[39m]\n", + "File \u001B[0;32m/Library/Python/3.9/site-packages/because/probability/rcot/lpb4.py:59\u001B[0m, in \u001B[0;36muniroot\u001B[0;34m(fun, limit, m_vec, N, tol)\u001B[0m\n\u001B[1;32m 58\u001B[0m \u001B[38;5;28;01mfrom\u001B[39;00m \u001B[38;5;21;01mscipy\u001B[39;00m\u001B[38;5;21;01m.\u001B[39;00m\u001B[38;5;21;01moptimize\u001B[39;00m \u001B[38;5;28;01mimport\u001B[39;00m brentq \u001B[38;5;28;01mas\u001B[39;00m root\n\u001B[0;32m---> 59\u001B[0m x \u001B[38;5;241m=\u001B[39m \u001B[43mroot\u001B[49m\u001B[43m(\u001B[49m\u001B[43mfun\u001B[49m\u001B[43m,\u001B[49m\u001B[43mlimit\u001B[49m\u001B[43m[\u001B[49m\u001B[38;5;241;43m0\u001B[39;49m\u001B[43m]\u001B[49m\u001B[43m,\u001B[49m\u001B[43mlimit\u001B[49m\u001B[43m[\u001B[49m\u001B[38;5;241;43m1\u001B[39;49m\u001B[43m]\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43margs\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43m(\u001B[49m\u001B[43mm_vec\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mN\u001B[49m\u001B[43m)\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mxtol\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mtol\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 60\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m x\n", + "File \u001B[0;32m/Library/Python/3.9/site-packages/scipy/optimize/_zeros_py.py:784\u001B[0m, in \u001B[0;36mbrentq\u001B[0;34m(f, a, b, args, xtol, rtol, maxiter, full_output, disp)\u001B[0m\n\u001B[1;32m 783\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mValueError\u001B[39;00m(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mrtol too small (\u001B[39m\u001B[38;5;132;01m%g\u001B[39;00m\u001B[38;5;124m < \u001B[39m\u001B[38;5;132;01m%g\u001B[39;00m\u001B[38;5;124m)\u001B[39m\u001B[38;5;124m\"\u001B[39m \u001B[38;5;241m%\u001B[39m (rtol, _rtol))\n\u001B[0;32m--> 784\u001B[0m r \u001B[38;5;241m=\u001B[39m \u001B[43m_zeros\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_brentq\u001B[49m\u001B[43m(\u001B[49m\u001B[43mf\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43ma\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mb\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mxtol\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mrtol\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mmaxiter\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43margs\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mfull_output\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mdisp\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 785\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m results_c(full_output, r)\n", + "\u001B[0;31mValueError\u001B[0m: f(a) and f(b) must have different signs", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001B[0;31mAttributeError\u001B[0m Traceback (most recent call last)", + "Cell \u001B[0;32mIn[13], line 1\u001B[0m\n\u001B[0;32m----> 1\u001B[0m \u001B[43mcmodel\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mshow\u001B[49m\u001B[43m(\u001B[49m\u001B[43mprobspace\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mps\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mtargetSpec\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43m[\u001B[49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[38;5;124;43mgenhealth\u001B[39;49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[38;5;124;43mgender\u001B[39;49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[38;5;124;43mdrinks\u001B[39;49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[43m,\u001B[49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[38;5;124;43mphysicalactivity\u001B[39;49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[43m]\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43medgeLabels\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[38;5;124;43mrho\u001B[39;49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[43m)\u001B[49m\n", + "File \u001B[0;32m~/Documents/Causality/Because/because/visualization/cmodel.py:67\u001B[0m, in \u001B[0;36mshow\u001B[0;34m(dataPath, numRecs, targetSpec, condSpec, controlFor, gtype, probspace, cg, edgeLabels, enhance, power, maxLevel, sensitivity, verbosity)\u001B[0m\n\u001B[1;32m 65\u001B[0m vprint(\u001B[38;5;241m3\u001B[39m, verbosity, \u001B[38;5;124m'\u001B[39m\u001B[38;5;124mcmodel.show: Performing Discovery.\u001B[39m\u001B[38;5;124m'\u001B[39m)\n\u001B[1;32m 66\u001B[0m \u001B[38;5;66;03m# If we didn't get a cgraph, discover one.\u001B[39;00m\n\u001B[0;32m---> 67\u001B[0m cg \u001B[38;5;241m=\u001B[39m \u001B[43mcdisc\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mdiscover\u001B[49m\u001B[43m(\u001B[49m\u001B[43mprob1\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mvarNames\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mtargets\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mmaxLevel\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mmaxLevel\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mpower\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mpower\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43msensitivity\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43msensitivity\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mverbosity\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mverbosity\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 69\u001B[0m edges \u001B[38;5;241m=\u001B[39m []\n\u001B[1;32m 70\u001B[0m edgeLabelDict \u001B[38;5;241m=\u001B[39m {}\n", + "File \u001B[0;32m~/Documents/Causality/Because/because/causality/cdisc.py:251\u001B[0m, in \u001B[0;36mdiscover\u001B[0;34m(ps, varNames, maxLevel, power, sensitivity, verbosity)\u001B[0m\n\u001B[1;32m 248\u001B[0m \u001B[38;5;66;03m# print(f\"Calculating indeps: {v1}, {v2}\")\u001B[39;00m\n\u001B[1;32m 249\u001B[0m indeps \u001B[38;5;241m=\u001B[39m calc_indeps\u001B[38;5;241m.\u001B[39mcalculateOne(ps, v1, v2, varNames\u001B[38;5;241m=\u001B[39mmediaries,\n\u001B[1;32m 250\u001B[0m minLevel\u001B[38;5;241m=\u001B[39mlevel, maxLevel\u001B[38;5;241m=\u001B[39mlevel, power\u001B[38;5;241m=\u001B[39mpower, sensitivity\u001B[38;5;241m=\u001B[39msensitivity)\n\u001B[0;32m--> 251\u001B[0m \u001B[38;5;28;01mfor\u001B[39;00m indep \u001B[38;5;129;01min\u001B[39;00m indeps:\n\u001B[1;32m 252\u001B[0m \u001B[38;5;66;03m# If we find any independencies, direct or conditional, mark it as not causal.\u001B[39;00m\n\u001B[1;32m 253\u001B[0m spec, isInd \u001B[38;5;241m=\u001B[39m indep\n\u001B[1;32m 254\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m isInd:\n", + "File \u001B[0;32m~/Documents/Causality/Because/because/causality/calc_indeps.py:54\u001B[0m, in \u001B[0;36mcalculateOne\u001B[0;34m(ps, v1, v2, varNames, minLevel, maxLevel, sensitivity, power)\u001B[0m\n\u001B[1;32m 52\u001B[0m \u001B[38;5;66;03m#print('calculateOne: v1, v2, conds = ', v1, v2, conds)\u001B[39;00m\n\u001B[1;32m 53\u001B[0m num_f \u001B[38;5;241m=\u001B[39m \u001B[38;5;241m100\u001B[39m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28mlen\u001B[39m(conds) \u001B[38;5;241m==\u001B[39m \u001B[38;5;241m0\u001B[39m \u001B[38;5;28;01melse\u001B[39;00m \u001B[38;5;241m100\u001B[39m \u001B[38;5;241m*\u001B[39m \u001B[38;5;28mlen\u001B[39m(conds)\n\u001B[0;32m---> 54\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[43mps\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43misIndependent\u001B[49m\u001B[43m(\u001B[49m\u001B[43mv1\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mv2\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mconds\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mpower\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mpower\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43msensitivity\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43msensitivity\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mnum_f\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mnum_f\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mseed\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;241;43m1\u001B[39;49m\u001B[43m)\u001B[49m:\n\u001B[1;32m 55\u001B[0m \u001B[38;5;28;01myield\u001B[39;00m(item, \u001B[38;5;28;01mTrue\u001B[39;00m)\n\u001B[1;32m 56\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n", + "File \u001B[0;32m~/Documents/Causality/Because/because/probability/prob.py:2100\u001B[0m, in \u001B[0;36mProbSpace.isIndependent\u001B[0;34m(self, rv1, rv2, givenSpecs, power, seed, num_f, num_f2, sensitivity, dMethod)\u001B[0m\n\u001B[1;32m 2096\u001B[0m \u001B[38;5;250m\u001B[39m\u001B[38;5;124;03m\"\"\" Determines if two variables are independent, optionally given a set of givens.\u001B[39;00m\n\u001B[1;32m 2097\u001B[0m \u001B[38;5;124;03m Returns True if independent, otherwise False\u001B[39;00m\n\u001B[1;32m 2098\u001B[0m \u001B[38;5;124;03m\"\"\"\u001B[39;00m\n\u001B[1;32m 2099\u001B[0m \u001B[38;5;66;03m# print(f\"Testing isIndependent(prob): {rv1}, {rv2}\")\u001B[39;00m\n\u001B[0;32m-> 2100\u001B[0m ind \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mindependence\u001B[49m\u001B[43m(\u001B[49m\u001B[43mrv1\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mrv2\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mgivenSpecs\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43m \u001B[49m\u001B[43mgivenSpecs\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mpower\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43m \u001B[49m\u001B[43mpower\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mseed\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mseed\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mnum_f\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mnum_f\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mnum_f2\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mnum_f2\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 2101\u001B[0m \u001B[43m \u001B[49m\u001B[43msensitivity\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43msensitivity\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mdMethod\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mdMethod\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 2102\u001B[0m \u001B[38;5;66;03m# Use .5 (50% confidence as threshold.\u001B[39;00m\n\u001B[1;32m 2103\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m ind \u001B[38;5;241m>\u001B[39m \u001B[38;5;241m.5\u001B[39m\n", + "File \u001B[0;32m~/Documents/Causality/Because/because/probability/prob.py:2088\u001B[0m, in \u001B[0;36mProbSpace.independence\u001B[0;34m(self, rv1, rv2, givenSpecs, power, seed, num_f, num_f2, sensitivity, dMethod)\u001B[0m\n\u001B[1;32m 2077\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21mindependence\u001B[39m(\u001B[38;5;28mself\u001B[39m, rv1, rv2, givenSpecs\u001B[38;5;241m=\u001B[39m[], power\u001B[38;5;241m=\u001B[39m\u001B[38;5;28;01mNone\u001B[39;00m, seed\u001B[38;5;241m=\u001B[39m\u001B[38;5;28;01mNone\u001B[39;00m, num_f\u001B[38;5;241m=\u001B[39m\u001B[38;5;241m100\u001B[39m, num_f2\u001B[38;5;241m=\u001B[39m\u001B[38;5;241m5\u001B[39m, sensitivity\u001B[38;5;241m=\u001B[39m\u001B[38;5;241m5\u001B[39m,\n\u001B[1;32m 2078\u001B[0m dMethod\u001B[38;5;241m=\u001B[39m\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mrcot\u001B[39m\u001B[38;5;124m'\u001B[39m):\n\u001B[1;32m 2079\u001B[0m \u001B[38;5;250m \u001B[39m\u001B[38;5;124;03m\"\"\"\u001B[39;00m\n\u001B[1;32m 2080\u001B[0m \u001B[38;5;124;03m Calculate the independence between two variables, and an optional set of givens.\u001B[39;00m\n\u001B[1;32m 2081\u001B[0m \u001B[38;5;124;03m This is a heuristic inversion\u001B[39;00m\n\u001B[0;32m (...)\u001B[0m\n\u001B[1;32m 2086\u001B[0m \u001B[38;5;124;03m TO DO: Calibrate to an exact p-value.\u001B[39;00m\n\u001B[1;32m 2087\u001B[0m \u001B[38;5;124;03m \"\"\"\u001B[39;00m\n\u001B[0;32m-> 2088\u001B[0m dep \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mdependence\u001B[49m\u001B[43m(\u001B[49m\u001B[43mrv1\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mrv2\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mgivenSpecs\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mgivenSpecs\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mpower\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mpower\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mseed\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mseed\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mnum_f\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mnum_f\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mnum_f2\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mnum_f2\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 2089\u001B[0m \u001B[43m \u001B[49m\u001B[43msensitivity\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43msensitivity\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mdMethod\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mdMethod\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 2090\u001B[0m ind \u001B[38;5;241m=\u001B[39m \u001B[38;5;241m1\u001B[39m \u001B[38;5;241m-\u001B[39m dep\n\u001B[1;32m 2091\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m ind\n", + "File \u001B[0;32m~/Documents/Causality/Because/because/probability/prob.py:1951\u001B[0m, in \u001B[0;36mProbSpace.dependence\u001B[0;34m(self, rv1, rv2, givenSpecs, power, raw, seed, num_f, num_f2, sensitivity, dMethod)\u001B[0m\n\u001B[1;32m 1949\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m DEBUG:\n\u001B[1;32m 1950\u001B[0m \u001B[38;5;28mprint\u001B[39m(\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mProbSpace.dependence: RCoT Failed. Using discrete method:\u001B[39m\u001B[38;5;124m'\u001B[39m, rv1, rv2, givenSpecs)\n\u001B[0;32m-> 1951\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mdependence\u001B[49m\u001B[43m(\u001B[49m\u001B[43mrv1\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mrv2\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mgivenSpecs\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mpower\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mpower\u001B[49m\u001B[43m,\u001B[49m\u001B[43mdMethod\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[38;5;124;43md\u001B[39;49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[43m)\u001B[49m\n\u001B[1;32m 1952\u001B[0m \u001B[38;5;66;03m#assert 1 <= sensitivity <= 10, \"sensitivity should be from range [1, 10]\"\u001B[39;00m\n\u001B[1;32m 1953\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m sensitivity \u001B[38;5;241m>\u001B[39m\u001B[38;5;241m=\u001B[39m \u001B[38;5;241m10\u001B[39m:\n\u001B[1;32m 1954\u001B[0m \u001B[38;5;66;03m# Use 0.99 as threshold to determine whether a pair of variables are dependent\u001B[39;00m\n", + "File \u001B[0;32m~/Documents/Causality/Because/because/probability/prob.py:2008\u001B[0m, in \u001B[0;36mProbSpace.dependence\u001B[0;34m(self, rv1, rv2, givenSpecs, power, raw, seed, num_f, num_f2, sensitivity, dMethod)\u001B[0m\n\u001B[1;32m 2005\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[1;32m 2006\u001B[0m \u001B[38;5;66;03m# Otherwise use the previously computed prob1\u001B[39;00m\n\u001B[1;32m 2007\u001B[0m prob1 \u001B[38;5;241m=\u001B[39m prevProb1\n\u001B[0;32m-> 2008\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[43mprob1\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mN\u001B[49m \u001B[38;5;241m<\u001B[39m\u001B[38;5;241m=\u001B[39m \u001B[38;5;241m1\u001B[39m:\n\u001B[1;32m 2009\u001B[0m \u001B[38;5;66;03m#print('Empty distribution: ', spec)\u001B[39;00m\n\u001B[1;32m 2010\u001B[0m \u001B[38;5;28;01mcontinue\u001B[39;00m\n\u001B[1;32m 2011\u001B[0m \u001B[38;5;66;03m#print('ss1.N = ', ss1.N)\u001B[39;00m\n", + "\u001B[0;31mAttributeError\u001B[0m: 'NoneType' object has no attribute 'N'" + ] + }, + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cmodel.show(probspace=ps, targetSpec=['genhealth', 'gender', 'drinks','physicalactivity'], edgeLabels='rho')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Discovery works ok with just a couple variables. May try to do discovery by just running through pairs with testDirection though." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-09T02:23:55.208615Z", + "start_time": "2023-08-09T02:23:52.961234Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pass 1 of 3\n", + "Pass 2 of 3\n", + "Pass 3 of 3\n", + "Detecting valid links.\n", + "\n", + "\tTesting physicalactivity -> gender direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 0.0 \n", + "Backward:0.0\n", + "Rho-value: 0.0\n", + "identifiable: False\n", + "triangles = []\n", + " cdisc.discover: found causal link: gender -> physicalactivity ( -0.0 )\n", + " cDisc.discover: Duration = 2.4\n" + ] + }, + { + "data": { + "text/plain": "" + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cdisc.discover(ps, varNames=['physicalactivity', 'gender'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Try with subspace. Condition across each age group; test gender and arthritis for each age group." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-09T02:23:58.253332Z", + "start_time": "2023-08-09T02:23:57.547731Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\tTesting gender -> arthritis direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 3.08708614227271e-11 \n", + "Backward:0.0251559686680477\n", + "Rho-value: -0.02515596863717684\n", + "identifiable: False\n" + ] + }, + { + "data": { + "text/plain": "-0.02515596863717684" + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ss = ps.SubSpace([('ageGroup', 1)])\n", + "ss.testDirection('gender', 'arthritis')" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-09T02:24:16.661252Z", + "start_time": "2023-08-09T02:24:10.830539Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\tTesting gender -> arthritis direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 3.08708614227271e-11 \n", + "Backward:0.0251559686680477\n", + "Rho-value: -0.02515596863717684\n", + "identifiable: False\n", + "-0.02515596863717684 \n", + "\n", + "\tTesting gender -> arthritis direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 0.0 \n", + "Backward:4.9960036108132044e-15\n", + "Rho-value: -4.9960036108132044e-15\n", + "identifiable: False\n", + "-4.9960036108132044e-15 \n", + "\n", + "\tTesting gender -> arthritis direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 0.0 \n", + "Backward:0.0\n", + "Rho-value: 0.0\n", + "identifiable: False\n", + "0.0 \n", + "\n", + "\tTesting gender -> arthritis direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 0.0 \n", + "Backward:0.0\n", + "Rho-value: 0.0\n", + "identifiable: False\n", + "0.0 \n", + "\n", + "\tTesting gender -> arthritis direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 0.0 \n", + "Backward:0.0\n", + "Rho-value: 0.0\n", + "identifiable: False\n", + "0.0 \n", + "\n", + "\tTesting gender -> arthritis direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 0.2002435392979206 \n", + "Backward:0.0\n", + "Rho-value: 0.2002435392979206\n", + "identifiable: True\n", + "0.2002435392979206 \n" + ] + } + ], + "source": [ + "# ageGroup values: {1,2,3,4,5,6}\n", + "for i in range(6):\n", + " ss = ps.SubSpace([('ageGroup', i+1)])\n", + " rho= ss.testDirection('gender', 'arthritis')\n", + " print(rho, id)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Seems like conditioning on ageGroup using subspace yields an unidentifiable relationship except in group 6. In this oldest group, gender -> arthritis is correctly identified." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.6" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/because/probability/ucm/model_analysis.ipynb b/because/probability/ucm/model_analysis.ipynb new file mode 100644 index 0000000..1ddd3a2 --- /dev/null +++ b/because/probability/ucm/model_analysis.ipynb @@ -0,0 +1,1135 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-09T03:17:13.475456Z", + "start_time": "2023-08-09T03:17:12.759654Z" + } + }, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import sys\n", + "import ucm\n", + "from because.synth import Reader\n", + "from because.probability import prob\n", + "from because.visualization import cmodel\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "start_time": "2023-08-09T03:17:12.786944Z" + }, + "is_executing": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\t**P-values** \n", + "Forward: 0.3866921299925631 \n", + "Backward:0.0\n", + "Rho-value: 0.3866921299925631\n", + "identifiable: True\n", + "(0.3866921299925631, True)\n" + ] + } + ], + "source": [ + "df = pd.read_csv(\"models/M2.csv\")\n", + "\n", + "A = np.array(df['A'].tolist())\n", + "B = np.array(df['B'].tolist())\n", + "\n", + "print(ucm.uniform_channel_test(B, A))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Test M1A:\n", + "Simple V structure\n", + "Note that the model definition file initializes a distribution at the top, and uses the choice() function with parameter p corresponding to the initial distributions." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "start_time": "2023-08-09T03:17:13.195177Z" + }, + "is_executing": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "getData: 10000 records read.\n", + "\n", + "\tTesting A -> B direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 2.5821678129034353e-11 \n", + "Backward:2.5821678129034353e-11\n", + "Rho-value: 0.0\n", + "identifiable: False\n", + "\n", + "\tTesting B -> C direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 4.508332707153784e-09 \n", + "Backward:5.5486102379376234e-09\n", + "Rho-value: -1.0402775307838397e-09\n", + "identifiable: False\n", + "triangles = [('B', 'A', 'C')]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Library/Python/3.9/site-packages/scipy/stats/_distn_infrastructure.py:2176: RuntimeWarning: divide by zero encountered in divide\n", + " x = np.asarray((x - loc)/scale, dtype=dtyp)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9025786428566827\n", + "Map = \n", + " A --> B ( 0.3 )\n", + " C --> B ( 0.3 )\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "filename = \"models/M1Aold.csv\"\n", + "ds = Reader(filename)\n", + "ps = prob.ProbSpace(ds.varData, categorical=['A', 'B', 'C'])\n", + "cmodel.show(probspace=ps, targetSpec=['A', 'B', 'C'], sensitivity=10, power=5, edgeLabels='rho', verbosity=1)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A->B<-C is the correct direction, and was correctly identified by the model." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Test M1A:\n", + "Simple V structure (with UCVar class variables)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-09T03:17:13.617271Z", + "start_time": "2023-08-09T03:17:13.209869Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "getData: 10000 records read.\n", + "\n", + "\tTesting A -> B direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 0.0 \n", + "Backward:0.0\n", + "Rho-value: 0.0\n", + "identifiable: False\n", + "\n", + "\tTesting B -> C direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 0.0 \n", + "Backward:0.0018509413153152687\n", + "Rho-value: -0.0018509413153152687\n", + "identifiable: False\n", + "triangles = [('B', 'A', 'C')]\n", + "Map = \n", + " B --> A ( -0.0 )\n", + " C --> B ( 0.002 )\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "filename = \"models/M1A.csv\"\n", + "ds = Reader(filename)\n", + "ps = prob.ProbSpace(ds.varData, categorical=['A', 'B', 'C'])\n", + "cmodel.show(probspace=ps, targetSpec=['A', 'B', 'C'], sensitivity=10, power=5, edgeLabels='rho', verbosity=1)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With modified file, the model did not do as well to predict the correct causal graph." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Conditioning using subspace might fix the issue:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "ExecuteTime": { + "start_time": "2023-08-09T03:17:13.223934Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\tTesting B -> C direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 0.0 \n", + "Backward:0.6964215668349265\n", + "Rho-value: -0.6964215668349265\n", + "identifiable: True\n", + "triangles = []\n", + "Map = \n", + " C --> B ( 0.696 )\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGdCAYAAACPX3D5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAqwUlEQVR4nO3deXjU1aH/8c9MJpOVLIRAIEACBAgUBEQUWQTLJhYUkFXZrNddasVeSy1CaLV69VakVWuxglJrfwgtVlqsiAUXUhUUBUWosoYlQEISYJKQZHJ+f+DkEpKwJTOTcN6v56HPwyzfcybEznu+yxmHMcYIAABYyxnsCQAAgOAiBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwZQp9555x3deuut6tChg2JiYhQWFqbmzZtryJAhmj9/vo4cORLsKfrdyy+/LIfDoenTp1/Q8xwOR5U/ERERSk1N1cSJE/Xhhx/W6Tx9YwTKxf5cgi01NVUOh0O7d+++oOdNnz5dDodDL7/8sl/mBdQlYgB1IicnR0OGDNHQoUP18ssvq7S0VNdee61uuukmderUSZmZmZo5c6batm2rjz/+ONjTrdeGDRumadOmadq0aRo0aJCKi4u1dOlSXXPNNVqwYEGwp1et3bt3y+FwKDU1NdhTAXARXMGeABq+goIC9evXT9u3b1d6eroWLlyo/v37V3rMyZMn9corr2ju3Lk6ePBgkGbaMMyaNUsDBw6s+HthYaGmTJmiv/71r3rooYc0duxYJScnB2+CF2n06NHq3bu3YmNjgz2VgHj88cc1a9YsNW/ePNhTAc6JPQOotRkzZmj79u1KTU3V+vXrq4SAJIWFhemOO+7Q559/rk6dOgVhlg1XZGSkfvvb30qSSkpK9Pbbbwd5RhcnNjZW6enp1rw5Nm/eXOnp6dbEDxo2YgC1snPnTr322muSpKefflqNGzc+6+ObNWumjh07Vvz9+PHjevHFFzVmzBi1b99eUVFRioqKUteuXfXzn/9c+fn51W7nXMe7Bw4cKIfDoXXr1lW6vaCgQLNnz1bXrl0VFRWlsLAwtWjRQn379tWcOXNUWlpa6fFr1qzRjBkz1L17dzVp0kRhYWFq2bKlJkyYoA0bNpz1tdalFi1aKCEhQZJ06NChah+zfPlyXXfddUpMTJTb7VZycrImT56srVu3XtBYW7du1dy5c9W3b18lJyfL7XYrISFBgwcP1uuvv17l8dOnT1ebNm0kSXv27Kly3oPPuc4Z+OSTTzR+/Hi1aNFCbrdbTZs21ciRI/XOO+9U+/jTj8nv2rVLU6ZMUVJSksLCwtSuXTvNnj1bJ0+erPK88vJyLVy4UH379lVcXJxCQ0PVtGlTdevWTTNmzDjruQFr167V0KFDFR8fr4iICF1++eVasmTJOed3uoyMDDkcDmVkZGjPnj2aOnWqmjdvrvDwcHXo0EEZGRkqKiqqdpvLli3T4MGDlZCQoNDQUCUkJKhz5866/fbbtXnz5hrnDZyTAWphwYIFRpKJi4szZWVlF/z8Dz74wEgyiYmJpl+/fmbChAlm6NChJiEhwUgyaWlpJicnp8rzJJmz/foOGDDASDJr166tuM3j8ZguXbpUjDdy5EgzceJEM3DgQJOUlGQkmby8vErbadeunXG73aZHjx7mhhtuMGPGjDGdO3c2kozL5TLLly+vMvbixYuNJDNt2rQL+ln4XtPpc/bxer0mLCzMSDIvvfRSpftKS0vN+PHjjSQTFhZm+vTpY8aNG2e6detmJJmIiAjz1ltv1TjemW677TYjyaSnp5thw4aZCRMmmKuvvto4nU4jyTzwwAOVHv/iiy+am266yUgyUVFRZtq0aZX+nM/PZeHChRXb79Gjh5k0aZLp06dPxRwzMjKqPGfatGlGkrn//vtNTEyMSUlJMePHjzeDBw82ERERRpIZNWpUlefdeuutRpIJDw83gwcPNpMmTTLDhg0z7du3N5LMihUrKj0+JSXFSDKPPPKIcTgcpmfPnmbixImmd+/eFfObP39+jfNbvHhxpdvnzp1rJJmpU6eahIQE06xZMzNu3DgzYsQIExUVZSSZvn37mqKiokrPmzdvXsXv3TXXXGMmTZpkrr/+etOlSxfjcDiqnQNwvogB1MqUKVOMJPP973//op6flZVl1qxZY7xeb6XbPR6PmTp1qpFk7rnnnirPu5gYeOWVV4wkM3z4cFNSUlLp8V6v16xbt86cPHmy0u0rVqwwR48erbL9FStWGJfLZRISEkxhYWGl+/wRA6tXrzaSjNvtNvv3769038MPP2wkmauuusrs3Lmz0n3Lli0zISEhJj4+vkro1PQzXLdundmxY0eV27dt22ZatmxpJJmPP/640n27du0ykkxKSkqNr6+mn8vmzZuNy+UyDofDLFmypNJ9q1atMm6320gyq1evrnSf781Wkvn5z39eKUa3bNlS8caamZlZcfuePXuMJNOyZUtz8ODBKnPcunWr2bNnT6XbfDEQGhpqVq5cWe1rio2NrfJ7cK4YkGRuvPHGSs/LysoyHTp0MJLMrFmzKm4vLi42ERERJjo62mzbtq3KvHfv3m2+/vrrKrcD54vDBKgV36WCTZs2vajnt2zZUoMGDZLTWflXMTIyUr/73e/kcrm0bNmyWs9T+r/d60OGDFFoaGil+5xOpwYMGCC3213p9lGjRik+Pr7KtkaNGqVx48YpNzdXa9eurZP5VScnJ0fLly/X9OnT5XQ69eyzz6pFixYV9x89elTz589XeHi4/vKXv1TsrvcZO3as7rzzTuXl5enVV189rzEHDBigtm3bVrm9Y8eOeuSRRySdOiRRVxYsWKCysjKNHj1aU6ZMqXTf8OHDdccdd0iSnnrqqWqf37NnT/3yl79USEhIxW1dunSp2NaaNWsqbvf9Dlx++eVKSkqqsq1OnTqpdevW1Y4zY8YMjRgxotJt06dPV3p6ugoKCrRx48ZzvdRKIiIi9MILLygiIqLitpYtW+rXv/61JOn5559XcXGxJOnYsWMqKipS27ZtKx1m80lJSVF6evoFjQ+cjqsJUC9kZmbqgw8+0N69e1VYWChjjCTJ7XbryJEjysvLq/ZN+UL06tVLkvTkk08qISFBI0aMOOc5DpJ04MAB/eMf/9C2bdtUUFCgsrIySdJXX30lSdq+fbuuv/76Ws3tdNdee22V2yIiIrR69WoNGjSo0u1r165VUVGRBg0aVOMVBgMHDtTzzz+vzMxM3Xfffec1hxMnTuitt97Spk2blJOTo5KSEkmquBJk+/btF/KSzsp3XkdN5xLcdtttevbZZ/XBBx/I6/VWetOXpBEjRlR7/ojvRNX9+/dX3Jaenq5GjRpp1apVeuyxx3TzzTdXCaiajBw5strbO3XqpG3btlUa53wMHTq02iAZMWKEEhISlJubq88++0x9+vRRYmKiUlNTtXnzZj344IO67bbb1Llz5wsaDzgbYgC1kpiYKEk6fPjwRT3/8OHDuummm865oM6xY8dqHQMDBw7UT3/6Uz311FOaNm2aHA6H2rdvr759++rGG2/UyJEjq+yhmDdvnh577LEqJxaeObe6NGzYMCUlJam8vFzZ2dl6//33VVRUpMmTJ2v9+vWVPrXv3LlTkvTuu++ecwGh813waeXKlbr11luVm5tb42Pq8jX73kRrelNu166dJKm4uFi5ublV9kLV9Ek+Jiam4nk+jRo10uLFi3Xrrbdq9uzZmj17tpo3b67evXvruuuu080336zo6Ohqt3ch45yPs0VIamqqcnNztW/fvorblixZorFjx+rpp5+uOFn3qquu0pAhQzRlyhQ1adLkgsYHTsdhAtRKz549JUmfffaZvF7vBT//v/7rv/Thhx/q6quv1urVq3Xo0CGVlJTInDqfpeIyNN+egvNVXl5e7e1PPPGEduzYod/85jcaN26cPB6PFi9erFGjRql3797yeDwVj/3rX/+qjIwMhYWF6fe//72++eYbeTwelZeXyxijn/3sZxc1t3OZNWuWXn75ZS1ZskSrV6/Wzp071aVLF2VnZ+vmm2+uNJ7vdaalpVUsVFTTnzP3KlRn//79mjBhgnJzc/XQQw/piy++UEFBgbxer4wxFZc11vVrro0zA+5cbrrpJmVlZWnJkiW6/fbbFR8frxUrVujOO+9UWlqatmzZUifj1IXTf879+/fX7t27tWzZMt13331KTU3V22+/XbGY17vvvhvw+eHSwZ4B1MqIESM0c+ZM5efn680339To0aPP+7kej0erVq2S0+nUqlWrFBcXV+X+7Ozsap8bGhqq0tJSHT9+XI0aNapy/549e2ocNzU1VTNmzNCMGTMkSRs2bNDkyZO1YcMGPfnkk5o3b54kVVxG99hjj1Uctz7dN998c16vs7ZatGihZcuW6bLLLtPHH3+sP/3pT5o8ebIkqVWrVpJOHc+vi2VvV65cqaKiIo0ePVr/8z//U+V+f7zm5ORk7dixoyJ6zuTb+xEeHn5eh3XOR2xsrKZMmVJxXkFWVpZmzJihv/3tb7rvvvv03nvv1ck4Z7Nr164a7/Nd3tiyZctKt0dERGjs2LEaO3aspFN7e2bPnq2FCxfqhz/84Vl/74GzYc8AaqVdu3aaNGmSJOnBBx/U0aNHz/r4w4cPVxxv9n3ijImJqRICkvTqq6/W+AnUd3z866+/rnLf5s2blZWVdd6voVevXrrnnnskSZ9//nnF7b7XkpKSUu3rqOn6d39IT0/X3XffLenUdeq+8xYGDRokt9utdevWXfShmtOd7TUbYyrWlDiT78RL37wuhG+1xZpiZtGiRZJOfTJ2ufzz+aVVq1YVEXj674A/rV69utp/s1WrVik3N1eNGjWq2PNWk8TERD355JOSpL179yovL88vc8WljxhArf32t79VWlqadu3apX79+lV7/L+kpESLFi1Sjx49Kt7AmzVrpvj4eOXn5+uPf/xjpcd/9NFHFbvhqzN48GBJp47pn76wzO7duzVt2rRqI2LFihV6//33qxxCKC0t1T//+U9Jld8EfSegLVy4sOIEOulUxEybNk0FBQU1zs8fZs+erejoaO3YsUOvvPKKpFM/wxkzZsjj8WjkyJHV7uI+efKk3nzzTW3btu2cY/he8/LlyystG+31ejVnzhxlZmZW+zzfQkfZ2dnnDMIz3X///XK5XHrjjTeqXPGwevVq/f73v5ck/eQnP7mg7VZn06ZNWrp0abWL+qxcuVJS9SHkD0VFRbr77rsrzeXAgQN68MEHJUl33XWXwsPDJZ3a0/WHP/yh2nM1fPOOj4+vOH8BuFAcJkCtxcfHa/369ZowYYLWrVun/v37q02bNrrssssUGRmpQ4cO6ZNPPtGJEycUExNTcWlcSEiI5syZowceeEBTp07Vc889p7Zt22rv3r3KzMzU5MmT9f7771e76/Phhx/W8uXLtWrVKnXo0EG9evXSkSNHtGHDBvXt21d9+vSp8sb13nvvacGCBWrSpIl69Oihpk2b6vjx4/roo490+PBhJScn66GHHqp4/I9//GMtWbJEq1atUtu2bdW7d2+VlpbqvffeU2RkpH74wx9WfGoNhMTERM2cOVO/+MUv9Oijj2rq1KkKDQ3VE088oYMHD+q1115T9+7d1a1bN7Vt21Yul0v79u3T559/Lo/Ho7feeuucl5+NHDlSPXv21KeffqoOHTpowIABioqK0scff6wDBw7opz/9abWHD0JDQ3XDDTdo+fLl6t69u/r166fIyEhJ0h/+8Iezjtm1a1c999xzuvvuuzVlyhTNnz9f6enp2rNnjzIzM2WMUUZGhoYOHXrxP7zv7NmzRxMnTqxYPbBVq1YqKyvTli1btH37drnd7opP2v42depU/f3vf1fbtm3Vv39/FRcX61//+pc8Ho+uvvrqij0VkpSXl6fbb79d99xzj7p3715x8uE333yjTZs2yeFw6KmnnqpypQVw3oKxuAEuXW+99ZaZOnWqSUtLM9HR0SY0NNQkJSWZIUOGmGeeecbk5uZWec4bb7xh+vTpY+Li4kx0dLS54oorzPPPP2/Ky8srFnzZtWtXledt3brVjBkzxsTHx5uwsDDTsWNH8+ijj5qSkpJqFx3atGmTmTVrlunXr59JTk42brfbJCYmmp49e5pf/epX1a50uGvXLnPLLbeY1q1bm7CwMJOSkmLuuusuk52dXbF4zNy5cys9xx+LDvkcO3bMJCYmGknmhRdeqHTfqlWrzJgxY0xycrIJDQ01cXFxplOnTmbixInmtddeMx6Pp9rxznT8+HHz8MMPm44dO5rw8HDTtGlTM2rUKLNx40azdu1aI8kMGDCgyvNyc3PNnXfeaVq3bm1CQ0OrbP9cP5ePPvrIjB071iQlJVUs6PSDH/ygymJDPjUt6nO28Q4ePGieeOIJc/3115s2bdqYyMhIExMTYzp37mzuvffeahf0Odvv4Nnmca5Fh+bOnWt27txpJk2aZJo1a2bcbrdJS0szc+bMqfJvdezYMfPMM8+Y0aNHm/bt25vo6GgTFRVlOnToYKZOnWo2btxY7dyA8+Uwph6dFgwAl7iMjAzNmzdPc+fOVUZGRrCnA0jinAEAAKxHDAAAYDliAAAAy3HOAAAAlmPPAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWM4V7AnUljFGnmKvjhd75fUaecuNJCnE6ZDTKUVHuNQoPEQOhyPIMwUANETecqNdOSe084hHxWXlKi71yiEpLDREkaEhatc0WimNI+V0Ntz3mQYXAyVl5TqcX6I8T6nyTpQq31Mqb/nZn+N0SHFRLsVHuxUX5VLTWLfC3SGBmTAAoEE5fLxY67/N0ZZ9x/R5Vp6+OnBMJ8vO/kYT6Q5R1+RYdWsVpy7JsbqmfRPFRboDNOPacxhjTLAncT7yTpRqZ3ahsnKLZYzkcEgXOnPfcxySWiSEqW2zSCU0CmWvAQBYzhijT3Yd1ZJ/79FbXx5UuZFcTofKyi/sjcb3nNAQh27s3kJTeqeqW6s4/0y6DtXrGCgvN8rKKdaO7EIVFJbJIamuJuvbVnR4iNolRSqlaYRCGvAuHgDAhSsu9WrZxiwtztytnUc8CnE6Kg4315ZvW51bxGh6n1SN6p4st6t+nqpXb2Mg31Oqjd8W6HiRNyDjRYaF6Iq0GCU0aji7dQAAF2/j7qN6YOnn2pdXJKnuPmyeybdXukOzaM2f0F3faxHrp5EuXr2LgfJyo+0HPNq+zyPJf/84Z/LtKUhrHqnOraLZSwAAl6iiEq/+d/V2LfpwlxwOqY52BJxTiMMhI6MfDWqvewam1au9BPUqBgo8pdoQwL0BNWEvAQBcmj7dk6cf/79N2p9fFLAIOJNDUvtm0VowsYc6NY8JziTOUG9i4EhBif69PU/l5YHbG1ATx3f/c2X7WLVoHB7k2QAA6sLbX2Xr3j99pnJjghYCPiFOh0JDHFo8/Upd3S4huJNRPYmB7LyT+ug/+Rd8dUAg9GwXo9aJEcGeBgCgFlZs2qcHX/9CxgT/A6eP0yE5nQ4tnNJT309vFty5BHV0SYcL6m8ISNKnO45p/9HiYE8DAHCR3tpyUDNf/0Ll9SgEpFPnKni9Rncs+VSZ3+YEdS5BjYG8E6X697b6GwI+G/5ToMMFJ4M9DQDABVr/bY7u+/Om+lUBpzGSyo3RrS9v0JZ9BUGbR9BiwFtu9Mk3BfU+BKRT/1gbvilQyTlWoAIA1B/5hSWa8edNKjemvraApFN7CEq95br3tc9UXBqcE+iDFgNbs06o8KS3Xv8Dna60zGjz7uPBngYA4DxlrNyq/MKSBvGhs9xIWXmF+vXq7UEZPygxkHu8RN8eLAzG0BfNSMrKKdbBPA4XAEB9t2brIb2xaX/Qrxq4EMZIf/hglz7dczTgYwc8BrzlRhu/PaaGuqTPZzs4XAAA9Vl+YYke+stmNcSvnXE4pAeWfhHwwwUBj4FvDxY2qMMDZyotM9q+3xPsaQAAavDsv75VQWFpgzg8cCbf4YLF63cHdNyAxoAxRjuzG9bhgTMZSbsPF6nM2wB/ywDgEldU4tWfN+yVtyGWwHeMkV7J3F1nX5h0PgIaA9n5JSoubfi72Mu8RvtzWXsAAOqblV8ckOdkcJe0rwvZx4q1bvvhgI0X0BjYmV3YYM8VONOOBr6HAwCCaVPWXv3u/bXal1d3J8sZY7R4/S5dCt8zF+J06JXM3QEbzxWogU4Ul+lwQUmghvO7gsIy5Z0oVXx0aLCnAgANysmyUo343TM6Vlys2StXaFrvPpr5/aFqGd+4Vtv9Yl+Bvs6+NC4B95YbffBNjvbkepSSEOX38QK2Z2B/7slLZq+AdOrLjPZxqAAALlheYaGOFZ/6/88Sb5leXP++uv0qQzP/8v9qtafg718ckOtS2C3wHYdDWrUlOyBjBWzPQP6JUr+Pkb1vt1a8+pw2b3hPR3MOyeUKVet2ndR30A0acuNkhYXX3RcOGZ1aThkAUHu+KHjlo8yL3lPweVa+yvx00t2JLWuUu+qZSrc5I2MV2qS1Yq+8SRHtrvDLuJv35ftlu2cKWAwc9ZT69XLCjevf0f/+/A6Fut0aOHycWrdNV1lpib7e/ImWPPsLZe3arrtn/W+djpnvKZUxRo6GeDErANRDFxsF5eVGXx7w/9r+sf1ukSsuSTJGXk++PF+u0eHlGUq8aY4i066s07HKjbQpK79Ot1mTgBwmOFlaruIS/11FcOjAHj095y4lJrXUgtfe120PPKohN07W8LE/1MxfvKAFr72vVm061vm43nLpRHHDP2sVl77nnntObdq0UUREhHr37q0NGzbU+Nhrr71WTqezyp+RI0cGcMaw3YUePtiZ4wnI1WoRba9Q9PeuVXSX7yv2qjFqdsuTktMlz9fv+WW87IJi5Rf6/3y7gMRAgce/u9PfePU5FRd6dO/DT6txk6rfCd28VRuNmHC7X8bO9/NrA2pr6dKlevDBBzVv3jxt2rRJ3bp107Bhw5STU/1Xpq5YsULZ2dkVf7788kuFhIRo/PjxAZ45cP5R8OX+4HzjnzMsSg6XWw5niN/G+HL/Mb9t2ycwMVBU5tftb/jwHTVLTlH6Zb38Os6ZHA7pWKF/XxtQW/Pnz9edd96pqVOnKj09XS+88IIiIyO1aNGiah8fFxenpk2bVvxZvXq1oqKiNHbs2ADPHPg/54qC7YeOB+TkwfKTHnkLC+QtLFDJkT06uvo5mdJiRXW+1i/jOR3Stmz/x0BAzhko8xo5HPLL0pCFnuM6euSgrrzmurrf+LkYKfvYcXn35wd+bOA07RObKcLtrnJ7aWmpPv30Uz388MMVtzkcDg0ePFj//ve/z2vbixYt0qRJkxQRUf0JuEUlJfrmyKGLmzislHPixEU/1xcFL3+0XiO6XKZHht+g9k2byXMyMB/MDi+dXfmGkFAlDL9fEW16+GU8p8MRkEWUAhID/lxSsdBz6prSiMhov41Rk7Jyr97c/IUWbVwZ8LGB02X+5GF1bdGyyu05OTnyer1q1qzy4bNmzZpp+/Zzf1XqJ598oq+++kqLFy+u8THf5hxW318/fuGTBmqh1OvVii826Y0vNumDmT8L2Bf7NB5yt1yNkyVJXk+ePF+tU+4/fyOnO0KRHfvU+XgOh1RcdonEgD+XiI6MaiRJKiq8+NKsDSdXEuAS9tJLL6lr167q2bNnsKcCVMtI2rw/S97yqIB8AZ67eQeFNW9f8feozgN0cPGPdHTNC4pI6yVHSN0vRFcegO8oCEgMhPjxOE5kVCM1bpKkvTu2+W2MmjgdTqUlJuq2Pv0DPjZwusaR1a9Q1qRJE4WEhOjQocq78Q8dOqSkpKSzbrOwsFBLly7Vo48+es6x+W8AF6KwpER/3vhxrbfjdrk0utvlmnzl1fr6wJdBWdjO4XAqvPVlOv7pmyo9ekDuxJQ63b4xUpjL/6f3BS4G/Bg2PfsO0Tt/+6O2b9mojl39s/BDdZxOh/qnddC9qXxqQv0UGhqqnj176t1339UNN9wg6dT67e+++65+9KMfnfW5r7/+ukpKSnTLLbec9XHJcfF6ZuykOpszLn3ZxwpqFQPxEZGaMXCQ7uw/UDHfLSYX7gpR0Ja5Nad245vSul+V1kgKC/XflQo+AbmaIDLM6dfdN6Mn36vwiEg9//hM5R89UuX+7H279felL9b5uMZIkWH+/0cCamPmzJl68cUXtWTJEm3btk133XWXCgsLNX36dEnS1KlTK51g6PPSSy9p1KhRio+PD/CMgerFR0RqzvCR+vKRX+q/hwyvCAFJahkfEdCv/PUx3jIV7dokhbgUmtCqzrfvLTdq1Tiyzrd7poDsGYiL8u+X+SS1TNWP5/1OT8++Uz+a2F8Dho9T63anViDcvmWjMv+1UtdeP8EvY8dHB2wRR+CijB8/Xjk5OZozZ44OHTqk7t276+2331ZiYqIkad++fXK5Kv8e/+c//1FmZqbeeeedYEwZqKS6PQFn6toy1q/np/kU7dyo0qP7JEnlnnx5vn5PZXkHFNN7rJxh/nnT7poc65ftns5hjP9/fMYYrdxwWF4/Lw51IGun/van5/XFJ6e+myA01K2UtM7qN/hGDblxskLdYXU+5sheTeUK4SRCADhf2ccK1D7jZ+d83PlEgI/nZJm6zH3bb3uhq/tuAofLLVfjlmrU/TpFdx/ul6XpI9wh+ipjmJx+XkMhIB9rHQ6H4qJClXvcv6v1tWjVts6/f+BsosJDCAEAqGMXEgE+UWEupSREanduoV/mFN11sKK7DvbLts+ma4sYv4eAFMAvKoqPDtXRE6UB2Y0TCA5JjaP9e/gDAGxyMRFwustbxysrrygo5w74g8vpULdWcYEZKyCjSEqMcevbg/4ptmAwkprGVl3xDQBwdmGuyh+kahsBPn3Smuivm/bXdnr1Rlm5UZ+0JgEZK2Ax0CzOrXC306/fXhhIrhCHkhPCgz0NAGhw4iMj9aOBg/XOtq80rscVtY4AnxGXNVfGm1/pRICWJva35rHhuqZ9YkDGCsgJhD7b93u0NSs4KwXWJYekds0j1TWlUbCnAgA4zWP/2KpF63c3+EMFTof00HXpumtAu8CMF5BRvpPaNEKXwuq9RlKbZrWvWABA3brlqpQGHwLSqaXux19R9+sW1DhewEaSFBbqVHLjsKAtElVXEmPdig5nfQEAqG9Sm0SpX1oTNeQLvUKcDo3s1kKNowJ3XlpAY0CSOiYH/tsF61p6cvXrwAMAgu/+we3V0HcO3D0wMIcHfAIeAzGRLqW3bLhvpu2SItUkhqsIAKC+6pXaWNP6pCoAl+f7xQOD26tDs8CekxbwGJCkDi2iFBPpanCHCyLcTnVu1fD3bADApe6h6zqqeWxEgzpcEOJ0qHPzRgE7afB0QYkBp9OhK9JigjF0rVyRFsuKgwDQAES6XXp6fDd5G9jhgvkTesgVEvi35qDEgCTFRoaqUwP6lM3hAQBoWK5qm6Db+rVpMHuhHxzaQR2TgnPJetBiQJI6tIhUSmL9X7ineXyYuqQ0nHABAJzys+HpGvK9ZvX+/IFJV7bS3UE4POAT1BhwOBzq0TZGyQl1/22CdSUx1q1e7WPlvBQWSAAAy7hCnPrtpB7q065JvQwCh06tnPjoqK5++dbD855HIFcgrEm5Mdq085j2HikO9lQqaR4fpl7tYxVSH3+DAADn7WSZV/e9tklrth7y29ccX4zxV7TU42MuC/r7TL2IAUkyxmhr1gn950D9+DKjNk0jdFmbRuwRAIBLRJm3XHP+9pVe+2SvnA4FbS2CkO/GvufadvrJ0I5B3SPgU29iwCfnWIk2flugoiB8oZFDkjvUqcvbxigpvv4eugAAXLy12w7rv5d/oaOekoAHgdMhtYiL0NPju+vKNo0DO/hZ1LsYkKQy76m9BDuyA7uXoHViuLqmNJLbFdRTKQAAflZQVKpf/n2rln+6LyB7CZwOyRjp1r5t9N/DOirCHeLfAS9QvYwBn5xjJdqy57jyPWVySHV+nMe3zUYRIerSuhF7AwDAMmu3H9bjq77Wfw6dUIjTUedfcuTb5mUtYzX7B53r1d6A09XrGPDJ95RqZ3ahsnKK66zeHA4puXGY2iZFqnF0aL04ZgMACDxjjD7bm68//nu3/r75oLzGqDbvjL53E7fLqTGXJ+uWq1LUJTm2TubqLw0iBnxKysq190iRDhw9qXxPWUXBOb7b/VKd0+8LcZ5a7CgpPkypTSMUFsrhAADA/8k5cVKvb8zSmq2HtPXgMRWXnjp/zeV0qKyGT6On3xfpDlHX5FgN/V6SxvZsqdiI0IDNvTYaVAyczhgjz0mv8k+UKd9TqmNFZSrzmopACHE65ApxKDrcpfhol+KiQhUdHsIeAADAefGWG+3K8ejL/QXasr9AO46cUFGJV4UlXjkdUnhoiKLCXGrfNFpdkmPVNTlWrRtHytkAL0dvsDEAAADqBvvJAQCwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFju/wOn6xCaN9QxwAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ss = ps.SubSpace([('A', 0)])\n", + "cmodel.show(probspace=ss, targetSpec=['B','C'], sensitivity=10, power=5, edgeLabels='rho', verbosity=1)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "ExecuteTime": { + "start_time": "2023-08-09T03:17:13.236797Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "triangles = []\n", + "Map = \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ss = ps.SubSpace([('C', 0)])\n", + "cmodel.show(probspace=ss, targetSpec=['A','B'], sensitivity=10, power=5, edgeLabels='rho', verbosity=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "ExecuteTime": { + "start_time": "2023-08-09T03:17:13.255731Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\tTesting A -> B direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 0.998365689534332 \n", + "Backward:0.9983656895343253\n", + "Rho-value: 6.772360450213455e-15\n", + "identifiable: False\n" + ] + }, + { + "data": { + "text/plain": [ + "6.772360450213455e-15" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ss.testDirection('A','B')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "TestDirection directly works but doesn't seem like it gets called with cmodel.show -> cdisc." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "ExecuteTime": { + "start_time": "2023-08-09T03:17:13.271056Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\tTesting A -> B direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 0.8541778959896855 \n", + "Backward:0.0\n", + "Rho-value: 0.8541778959896855\n", + "identifiable: True\n", + "triangles = []\n", + "Map = \n", + " A --> B ( 0.854 )\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ss = ps.SubSpace([('C', 1)])\n", + "cmodel.show(probspace=ss, targetSpec=['A','B'], sensitivity=10, power=5, edgeLabels='rho', verbosity=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "ExecuteTime": { + "start_time": "2023-08-09T03:17:13.280789Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\tTesting A -> B direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 0.10613366770504296 \n", + "Backward:0.0\n", + "Rho-value: 0.10613366770504296\n", + "identifiable: True\n", + "triangles = []\n", + "Map = \n", + " A --> B ( 0.106 )\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ss = ps.SubSpace([('C', 2)])\n", + "cmodel.show(probspace=ss, targetSpec=['A','B'], sensitivity=10, power=5, edgeLabels='rho', verbosity=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "ExecuteTime": { + "start_time": "2023-08-09T03:17:13.297407Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "triangles = []\n", + "Map = \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ss = ps.SubSpace([('B', 0)])\n", + "cmodel.show(probspace=ss, targetSpec=['A','B'], sensitivity=10, power=5, edgeLabels='rho', verbosity=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## M1A\n", + "Conditioning on A yields C->B\n", + "conditioning on B yields nothing (as expected)\n", + "conditioning on C yields A->B" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Test M1B:\n", + "Inverted V\n", + "structure\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "ExecuteTime": { + "start_time": "2023-08-09T03:17:13.308422Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "getData: 10000 records read.\n", + "0.9998141639216849\n", + "0.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Library/Python/3.9/site-packages/scipy/stats/_distn_infrastructure.py:2176: RuntimeWarning: divide by zero encountered in divide\n", + " x = np.asarray((x - loc)/scale, dtype=dtyp)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9989437890676743\n", + "\n", + "\tTesting A -> B direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 0.0 \n", + "Backward:0.24677843645412056\n", + "Rho-value: -0.24677843645412056\n", + "identifiable: True\n", + "\n", + "\tTesting B -> C direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 0.0 \n", + "Backward:0.0\n", + "Rho-value: 0.0\n", + "identifiable: False\n", + "triangles = [('B', 'A', 'C')]\n", + "Map = \n", + " B --> A ( 0.247 )\n", + " C --> B ( -0.0 )\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "filename = \"models/M1B.csv\"\n", + "ds = Reader(filename)\n", + "ps = prob.ProbSpace(ds.varData, categorical=['A', 'B', 'C'])\n", + "cmodel.show(probspace=ps, targetSpec=['A', 'B', 'C'], sensitivity=10, power=5, edgeLabels='rho', verbosity=1)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "B->A identified but not B->C (expected, since C does not have a uniform channel distribution)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "( Repeating M1B with the alternative distribution definition of C yields the correct directions B->A and B->C )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Test file: M1C (Growing Chain)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "ExecuteTime": { + "start_time": "2023-08-09T03:17:13.319487Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "getData: 10000 records read.\n", + "\n", + "\tTesting A -> B direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 0.6342994529476595 \n", + "Backward:0.0\n", + "Rho-value: 0.6342994529476595\n", + "identifiable: True\n", + "\n", + "\tTesting B -> C direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 0.8940868823851318 \n", + "Backward:0.0\n", + "Rho-value: 0.8940868823851318\n", + "identifiable: True\n", + "triangles = [('B', 'A', 'C')]\n", + "Map = \n", + " A --> B ( 0.634 )\n", + " B --> C ( 0.894 )\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGdCAYAAACPX3D5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABOFklEQVR4nO3deXwU9f3H8dfs5r5DCBDCHY4EEsiSAHIIKCAe3EfwAjwrHrRe9WetFWxrW49qra2t2laLLS0BUUFREQWRQyQh4Qo3AcJ95SB3sju/P2JSY7jJ7ibZ9/Px4PEwM7Pz/Uygnfd+v9/5jmGapomIiIh4LIu7CxARERH3UhgQERHxcAoDIiIiHk5hQERExMMpDIiIiHg4hQEREREPpzAgIiLi4RQGREREPJzCgIiIiIdTGJB69fnnn3PnnXfStWtXQkJC8PX1JSoqihEjRvDKK69w4sQJd5fodO+88w6GYXDHHXdc0ucMw6jzx9/fnw4dOnDzzTezatWqeq2zug1Xudzfi7t16NABwzDYt2/fJX3ujjvuwDAM3nnnHafUJVKfFAakXpw8eZIRI0Zw3XXX8c4771BRUcE111zDxIkTiYuLY82aNTz66KN06tSJdevWubvcBm3kyJFMnz6d6dOnM2zYMEpLS5k3bx6DBw/m1VdfdXd5Z7Vv3z4Mw6BDhw7uLkVELoOXuwuQxi8/P59BgwaxY8cOYmNjefPNN7n66qtrHVNWVsY///lPZs2axZEjR9xUaePw5JNPMnTo0Jqfi4uLmTp1KgsXLuSJJ55g0qRJREdHu6/AyzR+/HiuuuoqQkND3V2KS/z2t7/lySefJCoqyt2liFyQegbkis2cOZMdO3bQoUMHVq9eXScIAPj6+vKjH/2IzMxM4uLi3FBl4xUQEMBrr70GQHl5OZ999pmbK7o8oaGhxMbGeszNMSoqitjYWI8JP9K4KQzIFdm7dy9z584F4OWXX6ZZs2bnPb5ly5Z069at5uczZ87w1ltvMWHCBLp06UJgYCCBgYEkJCTw85//nLy8vLOe50Lj3UOHDsUwDFasWFFre35+Pk8//TQJCQkEBgbi6+tL69atGThwIM888wwVFRW1jl+2bBkzZ84kMTGR5s2b4+vrS5s2bZgyZQrr168/77XWp9atWxMREQHAsWPHznrMggULuP7664mMjMTHx4fo6Ghuv/12srKyLqmtrKwsZs2axcCBA4mOjsbHx4eIiAiGDx9OampqnePvuOMOOnbsCMD+/fvrzHuodqE5A99++y0pKSm0bt0aHx8fWrRowejRo/n888/Pevz3x+Szs7OZOnUqrVq1wtfXl5iYGJ5++mnKysrqfM7hcPDmm28ycOBAwsLC8Pb2pkWLFvTq1YuZM2eed27A8uXLue666wgPD8ff35/evXszZ86cC9b3fbNnz8YwDGbPns3+/fuZNm0aUVFR+Pn50bVrV2bPnk1JSclZzzl//nyGDx9OREQE3t7eRERE0L17d+699142bdp0zrpFLsgUuQKvvvqqCZhhYWFmZWXlJX/+66+/NgEzMjLSHDRokDllyhTzuuuuMyMiIkzA7Ny5s3ny5Mk6nwPM8/3zHTJkiAmYy5cvr9lWVFRkxsfH17Q3evRo8+abbzaHDh1qtmrVygTM3NzcWueJiYkxfXx8TJvNZo4ZM8acMGGC2b17dxMwvby8zAULFtRp++233zYBc/r06Zf0u6i+pu/XXM1ut5u+vr4mYP7973+vta+iosJMSUkxAdPX19ccMGCAOXnyZLNXr14mYPr7+5uffPLJOdv7obvvvtsEzNjYWHPkyJHmlClTzP79+5sWi8UEzEceeaTW8W+99ZY5ceJEEzADAwPN6dOn1/pzMb+XN998s+b8NpvNvOWWW8wBAwbU1Dh79uw6n5k+fboJmD/5yU/MkJAQs3379mZKSoo5fPhw09/f3wTMcePG1fncnXfeaQKmn5+fOXz4cPOWW24xR44caXbp0sUEzPfff7/W8e3btzcB8xe/+IVpGIaZlJRk3nzzzeZVV11VU98rr7xyzvrefvvtWttnzZplAua0adPMiIgIs2XLlubkyZPNUaNGmYGBgSZgDhw40CwpKan1uWeffbbm393gwYPNW265xbzxxhvN+Ph40zCMs9YgcrEUBuSKTJ061QTMa6+99rI+n5OTYy5btsy02+21thcVFZnTpk0zAfOBBx6o87nLCQP//Oc/TcC84YYbzPLy8lrH2+12c8WKFWZZWVmt7e+//755+vTpOud///33TS8vLzMiIsIsLi6utc8ZYWDp0qUmYPr4+JiHDh2qte+pp54yAbNfv37m3r17a+2bP3++abVazfDw8DpB51y/wxUrVph79uyps3379u1mmzZtTMBct25drX3Z2dkmYLZv3/6c13eu38umTZtMLy8v0zAMc86cObX2LVmyxPTx8TEBc+nSpbX2Vd9sAfPnP/95rTC6efPmmhvrmjVrarbv37/fBMw2bdqYR44cqVNjVlaWuX///lrbqsOAt7e3uXjx4rNeU2hoaJ1/BxcKA4A5duzYWp/Lyckxu3btagLmk08+WbO9tLTU9Pf3N4OCgszt27fXqXvfvn3mtm3b6mwXuVgaJpArUv2oYIsWLS7r823atGHYsGFYLLX/KQYEBPCXv/wFLy8v5s+ff8V1wv+610eMGIG3t3etfRaLhSFDhuDj41Nr+7hx4wgPD69zrnHjxjF58mROnTrF8uXL66W+szl58iQLFizgjjvuwGKx8Kc//YnWrVvX7D99+jSvvPIKfn5+vPfeezXd9dUmTZrEfffdR25uLv/6178uqs0hQ4bQqVOnOtu7devGL37xC6BqSKK+vPrqq1RWVjJ+/HimTp1aa98NN9zAj370IwBefPHFs34+KSmJX/3qV1it1ppt8fHxNedatmxZzfbqfwO9e/emVatWdc4VFxdHu3btztrOzJkzGTVqVK1td9xxB7GxseTn55OWlnahS63F39+fv/71r/j7+9dsa9OmDb///e8BeP311yktLQWgoKCAkpISOnXqVGuYrVr79u2JjY29pPZFvk9PE0iDsGbNGr7++msOHDhAcXExpmkC4OPjw4kTJ8jNzT3rTflS9OnTB4AXXniBiIgIRo0adcE5DgCHDx/m448/Zvv27eTn51NZWQnA1q1bAdixYwc33njjFdX2fddcc02dbf7+/ixdupRhw4bV2r58+XJKSkoYNmzYOZ8wGDp0KK+//jpr1qzhoYceuqgaCgsL+eSTT8jIyODkyZOUl5cD1DwJsmPHjku5pPOqntdxrrkEd999N3/605/4+uuvsdvttW76AKNGjTrr/JHqiaqHDh2q2RYbG0twcDBLlizhueee49Zbb60ToM5l9OjRZ90eFxfH9u3ba7VzMa677rqzBpJRo0YRERHBqVOn2LBhAwMGDCAyMpIOHTqwadMmHnvsMe6++266d+9+Se2JnI/CgFyRyMhIAI4fP35Znz9+/DgTJ0684II6BQUFVxwGhg4dyv/93//x4osvMn36dAzDoEuXLgwcOJCxY8cyevToOj0Uzz77LM8991ydiYU/rK0+jRw5klatWuFwODh69CgrV66kpKSE22+/ndWrV9f61r53714AvvjiiwsuIHSxCz4tXryYO++8k1OnTp3zmPq85uqb6LluyjExMQCUlpZy6tSpOr1Q5/omHxISUvO5asHBwbz99tvceeedPP300zz99NNERUVx1VVXcf3113PrrbcSFBR01vNdSjsX43whpEOHDpw6dYqDBw/WbJszZw6TJk3i5Zdfrpms269fP0aMGMHUqVNp3rz5JbUv8n0aJpArkpSUBMCGDRuw2+2X/Pl77rmHVatW0b9/f5YuXcqxY8coLy/HrJrPUvMYWnVPwcVyOBxn3f673/2OPXv28Mc//pHJkydTVFTE22+/zbhx47jqqqsoKiqqOXbhwoXMnj0bX19f3njjDXbt2kVRUREOhwPTNPnZz352WbVdyJNPPsk777zDnDlzWLp0KXv37iU+Pp6jR49y66231mqv+jo7d+5cs1DRuf78sFfhbA4dOsSUKVM4deoUTzzxBBs3biQ/Px+73Y5pmjWPNdb3NV+JHwa4C5k4cSI5OTnMmTOHe++9l/DwcN5//33uu+8+OnfuzObNm+ulnfrw/d/z1Vdfzb59+5g/fz4PPfQQHTp04LPPPqtZzOuLL75weX3SdKhnQK7IqFGjePTRR8nLy2PRokWMHz/+oj9bVFTEkiVLsFgsLFmyhLCwsDr7jx49etbPent7U1FRwZkzZwgODq6zf//+/edst0OHDsycOZOZM2cCsH79em6//XbWr1/PCy+8wLPPPgtQ8xjdc889VzNu/X27du26qOu8Uq1bt2b+/Pn07NmTdevW8e9//5vbb78dgLZt2wJV4/n1sezt4sWLKSkpYfz48Tz//PN19jvjmqOjo9mzZ09N6Pmh6t4PPz+/ixrWuRihoaFMnTq1Zl5BTk4OM2fO5MMPP+Shhx7iq6++qpd2zic7O/uc+6ofb2zTpk2t7f7+/kyaNIlJkyYBVb09Tz/9NG+++SZ33XXXef/di5yPegbkisTExHDLLbcA8Nhjj3H69OnzHn/8+PGa8ebqb5whISF1ggDAv/71r3N+A60eH9+2bVudfZs2bSInJ+eir6FPnz488MADAGRmZtZsr76W9u3bn/U6zvX8uzPExsZy//33A1XPqVfPWxg2bBg+Pj6sWLHisodqvu9812yaZs2aEj9UPfGyuq5LUb3a4rnCzD/+8Q+g6puxl5dzvr+0bdu2JgR+/9+AMy1duvSsf2dLlizh1KlTBAcH1/S8nUtkZCQvvPACAAcOHCA3N9cptUrTpzAgV+y1116jc+fOZGdnM2jQoLOO/5eXl/OPf/wDm81WcwNv2bIl4eHh5OXl8e6779Y6/ptvvqnphj+b4cOHA1Vj+t9fWGbfvn1Mnz79rCHi/fffZ+XKlXWGECoqKvj000+B2jfB6glob775Zs0EOqgKMdOnTyc/P/+c9TnD008/TVBQEHv27OGf//wnUPU7nDlzJkVFRYwePfqsXdxlZWUsWrSI7du3X7CN6mtesGBBrWWj7XY7zzzzDGvWrDnr56oXOjp69OgFA+EP/eQnP8HLy4sPPvigzhMPS5cu5Y033gDg8ccfv6Tznk1GRgbz5s0766I+ixcvBs4ehJyhpKSE+++/v1Ythw8f5rHHHgNgxowZ+Pn5AVU9XX/729/OOlejuu7w8PCa+Qsil0rDBHLFwsPDWb16NVOmTGHFihVcffXVdOzYkZ49exIQEMCxY8f49ttvKSwsJCQkpObROKvVyjPPPMMjjzzCtGnT+POf/0ynTp04cOAAa9as4fbbb2flypVn7fp86qmnWLBgAUuWLKFr16706dOHEydOsH79egYOHMiAAQPq3Li++uorXn31VZo3b47NZqNFixacOXOGb775huPHjxMdHc0TTzxRc/zDDz/MnDlzWLJkCZ06deKqq66ioqKCr776ioCAAO66666ab62uEBkZyaOPPsovf/lLfv3rXzNt2jS8vb353e9+x5EjR5g7dy6JiYn06tWLTp064eXlxcGDB8nMzKSoqIhPPvnkgo+fjR49mqSkJNLT0+natStDhgwhMDCQdevWcfjwYf7v//7vrMMH3t7ejBkzhgULFpCYmMigQYMICAgA4G9/+9t520xISODPf/4z999/P1OnTuWVV14hNjaW/fv3s2bNGkzTZPbs2Vx33XWX/8v7zv79+7n55ptrVg9s27YtlZWVbN68mR07duDj41PzTdvZpk2bxkcffUSnTp24+uqrKS0t5csvv6SoqIj+/fvX9FQA5Obmcu+99/LAAw+QmJhYM/lw165dZGRkYBgGL774Yp0nLUQumjsWN5Cm65NPPjGnTZtmdu7c2QwKCjK9vb3NVq1amSNGjDD/8Ic/mKdOnarzmQ8++MAcMGCAGRYWZgYFBZnJycnm66+/bjocjpoFX7Kzs+t8Lisry5wwYYIZHh5u+vr6mt26dTN//etfm+Xl5WdddCgjI8N88sknzUGDBpnR0dGmj4+PGRkZaSYlJZm/+c1vzrrSYXZ2tnnbbbeZ7dq1M319fc327dubM2bMMI8ePVqzeMysWbNqfcYZiw5VKygoMCMjI03A/Otf/1pr35IlS8wJEyaY0dHRpre3txkWFmbGxcWZN998szl37lyzqKjorO390JkzZ8ynnnrK7Natm+nn52e2aNHCHDdunJmWlmYuX77cBMwhQ4bU+dypU6fM++67z2zXrp3p7e1d5/wX+r1888035qRJk8xWrVrVLOh000031VlsqNq5FvU5X3tHjhwxf/e735k33nij2bFjRzMgIMAMCQkxu3fvbj744INnXdDnfP8Gz1fHhRYdmjVrlrl3717zlltuMVu2bGn6+PiYnTt3Np955pk6f1cFBQXmH/7wB3P8+PFmly5dzKCgIDMwMNDs2rWrOW3aNDMtLe2stYlcLMM0G9C0YBGRJm727Nk8++yzzJo1i9mzZ7u7HBFAcwZEREQ8nsKAiIiIh1MYEBER8XCaMyAiIuLh1DMgIiLi4RQGREREPJzCgIiIiIdTGBAREfFwCgMiIiIeTmFARETEwzWZFxXZHWbNHwCrxaj5IyIiIufWKMNAeaWDvMIKcosqySus4HRRBaXljrMe6+ttITzIi/BAb8ICvQkP8sbXWx0iIiIi1RrNokN2h8nh06XsPVrM6cJKAAyqXot2Mb5/bEiAFzGtAmgT4YeXVT0HIiLi2Rp8GCgus5N9rITs48VUVNZvqV5Wgw4t/OnYwp8g/0bZSSIiInLFGmwYqLSbZOUUsudo8SX1AFyq6nO3i/SjZ/tgvL00hCAiIp6lQYaBkwXlpO/Jp7js7PMAnMXX20JSTAgtw3xd2q6IiIg7Nagw8P3eAHdSL4GIiHiSBhMGSsvtrNqWy5kSu7tLAcDfx8LV3ZsR6Gd1dykiIiJO1SDCQHGZna+zTlNS5nDa3IBLZQA+XgaDujcjJECTC0VEpOlyez94Sbmdr7Y2rCAAVZMKyytNVmadprCk0t3liIiIOI1bw0BZhYOvs3IpK29YQaCaCVRWmnydlUtxWcMYvhAREalvbgsDpmmSvjuf4lJ7gwwC1UyqQsu3O/NoACMqIiIi9c5tYSDnZCnH8ssbdBCoZgK5RZXsPuLepxxEREScwS1hoKTczsbsM+5o+opk5RRyRvMHRESkiXF5GDBNk4w9BTVvF2xMTBPSd+druEBERJoUl4eBw6fLGs3wwA9VDxdkHytxdykiIiL1xuVhYNfhIlc3We92HSlS74CIiDQZLg0DeUUV5BY1/jH34jIHJwrK3V2GiIhIvXBpGMg+VoLhygadxAD2HtVQgYiINA0uCwPllQ4OnChplHMFfsgEjuSWUaKFiEREpAlwWRg4dKqURvgAwTkZwIGTpe4uQ0RE5Iq57A08pwsrMMApPQNffvxf/vTrh2ttCwmPoF3Hboy7/UF69x9W722awOkz5UBgvZ9bRETElVwWBnILK5w+RHDzvU/QsnU7TNMk7/QJli+Zx68fvY2nXpxD8qDr6r2904UV9X5OERERV3NJGLA7TM6UOH98vXf/a+kcl1jz8/DRt3LXTQl8/fkHTgkD5ZUmpeV2/Hys9X5uERERV3HJnIF8Nz1OGBgcio+vH1ar827WTeFRSRER8Wwu6RnIL3ZNd3px4RkK8k5hmib5uSdZMv8flJYUMfj6SU5pzwDyiyqICvd1yvlFRERcwSVhoKzCgWFUre3vTLN/PLnWz94+vjz41Csk9h3inAaNqkcmRUREGjMXzRlwRStw7+O/pXXbGADyck+w8tMFvP7bx/APDOKqoTc5pU1XXZuIiIizuCQMOFy0jn+X7rZaEwivHjGex6YP563fP0XSwBF4e/vUb4MmOJrS4gkiIuKRXDKB0GK4ZxFii8VCfO+B5J48xpGcvfXfgAEWS1NYYFlERDyZS8KA1eXvRvwfh71qtn9pSbFTzm9VGBARkUbOJbdpX2+L0ycPnk1lZQWZ336Fl7cPbTp0qf8GTPD1VhgQEZHGzSVzBsICvV3RDBvWfsmh/bsByM89yddLF3IkZy8Tps4kIDC43tszgdAA11ybiIiIs7gkDIQEeDntvQTf99+3Xqj5bx8fP6Lbd+a+nz7PdeOnOa3N8CCFARERadwM03RNB/4XG09S4IIliV3J19vCjUmR7i5DRETkirjsRUXhwT6cKSlxeu+AKzULurJfn93h4GRRIUfy8zlSkE9eSTEDOsbQvllEPVUoIiJyYS4LAxFB3uw/XuKq5lyiWfC51y0orajg2JkCDhfkc7Sg6mZ/pCCfI/n5HD2Tz5GCAo6dKcDuqL1qUavgEDKe+IWzSxcREanhsjDQOsKXjfuazop9BtCuuR+LNmeyJGsLvl5enC4u5khBHkcKCjhdXHRZ5y2t1GuRRUTEtVwWBrytFtpH+pN9rPEPFRhA62a+HMg7yX2p/67Xc4+J71Wv5xMREbkQly4H1LFlQKMPAlD1VESnVgH4etV/lppi61Pv5xQRETkfl4aBkAAvIoIb/6N4QX5WIoK9ad8sgt+NHk99LTsU0zwSW5u29XQ2ERGRi+PyhYK7tA50dZP1rkvrQIzv3rcwve8A/jBhSr2cNyUxuea8IiIiruLyMBAV7kvrZr719m3alQyo6hGI9Ku1PcWWzC9vHHNl5zYMJiX2vqJziIiIXA63vEIosWMIXtbGFwcMA5JiQs/67f3e/lfz2DUjLvvc/dp3pHVo2BVUJyIicnncEgZ8vS3YOoW4o+krktA+mEA/6zn3P3bNCO6+auBlnXvd/mymvvsPFm/ZSGmFHi8UERHXcdlyxGezbmceR06XNfgnDAygWbA3V3cPv+CYvsPh4OH3U5mfmX7Z7YX5+zM2IZEptmQSo9tqHoGIiDiVW8NARaWDlVm5nCmubLCBwAD8fS0M6dEMP59z9wp8X6Xdzj3/ncNn27Mu6vjuraLIKy7mcEF+nX2dm7cgxZbEpMQkokJCL6V0ERGRi+LWMABQVuHgqy2nKS6zN7hAYAA+3haGxjcjwPfigkC10ooKbn/376zO3nPBYz+45wGS27ZndfZuUjPS+Thrc52hAsMwGBzThZTEZK6P60GAz7mXQhYREbkUbg8DAKXldr7OyqWotOEEAgPw87FwdfdwAv0ub3GhwrJSJr/9JpmHcs55TIdmEax5+P9qDQWcKS3lo62bSM1M55t9e+t8JtjXj9HxPUmxJdO3XQcNI4iIyBVpEGEAoLzSweptueQVVbq7FKBqYaFB3cPxv8ihgXM5XVzE+L/9hZ0njp11/0+vvY5Hz/MUwv7Tp5ifmc78zHQO5J6us79js+ZMSuzNZFsybcPCr6hWERHxTA0mDAA4HCY7DhWx41DVS35cXZjxXZsxrQLo3jao3h5/PFKQz9i3/kxOXm6dfd8++jPahje74DkcDgff7M9mfmY6i7dsoqi8rM4xAzvGkGJL5qbuCQT6+tZL7SIi0vQ1qDBQLa+ogrTd+Zwpsbu03QBfC0kxoTQPqf/x+OxTJxn7tz9zorCwZtvAjjEsuGvGJZ+ruLycj7M2Mz8jjVXZe/jhX2GAjw+jeiSQkphM/w6dsFjc8gSpiIg0Eg0yDMD3egkOF+GKCuu7N+Bsso4eZsLf/0p+aQkAr06YQoot+YrOeTAvlwWZG0jNSCP79Mk6+9uEhTM5MYkUWxIdmjW/orZERKRparBhoFpZhYP9J0rYc7SY0nJHTVf+lag+h6+XQcdWAXRo4X/FcwMu1oacAzz2wXzahTfjzZun1tubD03TJC1nP6kZaXy4eSNnykrrHNO3fUdSEpMYE9+LYD+/s5xFREQ8UYMPA9VM0+RYXjl7jhZzIr+8JhBcTDj44THNg73p1CqAqHBfLJamNxO/pKKCz7ZtZV7Gelbu2YXjB3/Fft7e3BAXzxRbMoM6dcaqYQQREY/WaMLA99kdJvnFleQVVpBXVMHpwgoKS+11hhMMINDPSniQN+GB3oQFeREa4N0o34twuY4W5PPexg3My0hj14njdfZHhYQysVdvUmzJdIls4YYKRUTE3RplGDiX/3z1JXe++hIG8Pwd9/DjMRPcXVKDYZomGw8dJDUzjfc3ZZBXUlLnmN5t2pFiS2ZsQi/C/APcUKWIiLhD/QxYNyBlFXUfuZOqFQwT27QlsU1bZl0/ms93ZJGakcaXu3ZgdzgA2HDwABsOHmDWJ4u4rlt3UmzJDO3cFS+ra+ZTiIiIezS5MCAX5uvlxagePRnVoycnCs+wcFMGqRvSyDp2BICyykoWb93E4q2baBEUzIReNlISk4lrFeXmykVExBkUBjxcZFAw9w0YzH0DBrPlyCHmZVQNI5wqqlr46XjhGf66eiV/Xb2ShNbRpCQmM76njYjAQDdXLiIi9UVhQGrER0UTHxXNMyNH8eXO7aRmpvH5jm1U2KsWf9p8+BCbDx/il599xLCusUyxJXNtl1h86unxSBERcQ/9v7jU4W21MjKuByPjenCqqIgPN2cyLyONTYcPAlBht/Pptq18um0rzQICGd/TxhRbMvFRrfXSJBGRRkhhQM4rIjCQu64ayF1XDWTHsaOkZqaxIHMDxwvPAFUvYvr7N6v4+zeriGvZihRbMhN79SYyKNjNlYuIyMVqco8W3vrScwC8eu+DerTQSSrtdr7as4vUjDQ+276Vssrab5q0Wixc07kbU2zJjIjtXm+rLIqIiHPo/6XlknlZrQzrGsuwrrHklRSzaMtGUjPSSM85AIDd4WDZzm0s27mNMH9/xiUkkmJLJjG6rYYRREQaIIUBuSJh/gFM69OfaX36s/vEcVIz03kvM53DBfkA5JWU8M63a3nn27V0bt6CKbZkJib2Jiok1M2Vi4hINQ0TSL2zOxyszt7NvA1pLNm2hdKKilr7LYbB1TFdmGJL5vq4ePy9vd1UqYiIgHoGxAmsFguDY7oyOKYrZ0pLWbx1E6kZaazbnw2AwzT5avdOvtq9k2BfP8Yk9CIlMYk+7TpoGEFExA0UBsSpgv38uDWpL7cm9WXf6ZPMz0hnfmY6OXm5AJwpK+Xfaev4d9o6OjZrzmRbEpMSk2gbFu7mykVEPIeGCcTlHA4H3+zPJjUjjcVbN1FcXl7nmIEdY0ixJXNT9wQCfX3dUKWIiOdQz4C4nMViYUDHGAZ0jOG5m8bxcdZm5memszp7D9XZdHX2HlZn7+FnH73PqB4JTLH14ar2HbFYLG6uXkSk6VEYELcK9PUlxZZMii2ZnLxcFmSmMz8jnezTJwEoLi8nNSOd1Ix02oaFMzkxicm2JDo0a+7mykVEmg6FAWkw2oaF88jQ4Tw8ZBhpOfuZl5HGos0bOVNWCkBOXi4vr1jGyyuW0bd9R6bYkhndoyfBfn5urlxEpHFTGJAGxzAM+rTrQJ92HfjVjWP5bNtW5mWsZ+WeXTi+G0b4dn823+7P5ucff8CNcfGk2JIZ1KkzVg0jiIhcMoUBadD8vb0Z1zORcT0TOVKQz3uZG0jNTGPXieMAlFZUsHBTBgs3ZdA6JJSJiUmkJCbRObKFmysXEWk8FAak0YgKCeWhwdfw4NVD2XjoIPMy1vPB5kzySkoAOFyQz2srv+S1lV+S1LYdkxOTGZvQizD/ADdXLiLSsCkMSKNjGAaJbdqS2KYts28Yw+fbs0jNTOPLXTuwOxwApOccID3nALM+WcTI2B6k2JIYEtMVL6vVzdWLiDQ8CgPSqPl6eTEqviej4ntyovAM723cQGpGGtuOHQWgrLKSRVs2smjLRloEBTOxV29SbMnEtmzl5spFRBoOhQFpMiKDgpkxcAj3DRjMliOHSc1MY+HGDE4XFwFwvPAMf1n9FX9Z/RU9W7chxZbEuAQbEYGBbq5cRMS9FAakyTEMg4TW0SS0juYX193El7u2k5qRzrKd26iw2wHYdPggmw4f5NlPP2J41zhSbEkM6xqHt4YRRMQDKQxIk+bj5cX1cfFcHxfPqaIiPticQWpGOpsOHwSgwm7nk21b+GTbFpoFBDKhl42UxGTio1rrpUki4jEUBsRjRAQGcvdVg7j7qkFsP3aU1Iw03tu4geOFZwA4XVzE39au4m9rV9G9ZRSTbUlM7NWbyKBgN1cuIuJcelGReLRKu52v9uwkNSOdz7ZvpayystZ+q8XCtV26kZKYzIjY7vh6KT+LSNOj/2cTj+ZltTKsaxzDusaRV1LMh5s3Mj8zjfScAwDYHQ4+37GNz3dsI8zfn3EJiaTYkkmMbqthBBFpMhQGRL4T5h/A9L79md63P7tPHCc1M533MtM5XJAPQF5JCe98u5Z3vl1Ll8gWpCQmMzGxN1EhoW6uXETkymiYQOQ87A4Hq/buJjUjjSXbtlBaUVFrv8UwGBzThRRbMtfHxePv7e2mSkVELp96BkTOw2qxMKRzV4Z07sqZ0lIWb91EakYa6/ZnA+AwTVbs3smK3TsJ9vVjTEIvUhKT6NOug4YRRKTRUBgQuUjBfn7cmtSXW5P6su/0SeZnpJOamc7BvFwAzpSV8u+0dfw7bR2dIpozKTGJyYlJtAkLd3PlIiLnp2ECkSvgcDj4Zn82qRlpLN66ieLy8lr7DcNgYMcYJicmMapHTwJ8fNxUqYjIualnQOQKWCwWBnSMYUDHGJ67aRwfZ21mfmY6q/buBsA0TVbt3c2qvbt56qMPGNUjgRRbMle174jFYnFz9SIiVRQGROpJoK8vKbZkUmzJ5OTlsiAzndSMNPadPgVAUXkZ8zLSmJeRRtuwcCYnJjHZlkSHZs3dXLmIeDqFAREnaBsWziNDh/PwkGGsP7CP1Mx0Fm3eyJmyUgBy8nJ5ecUyXl6xjH7tO5JiS2Z0j54E+/m5uXIR8UQKAyJOZBgGfdt3pG/7jvzqxrF8um0LqRlprNyzC8d303XW7c9m3f5sfv7xB9wYF0+KLZlBnTpj1TCCiLiIwoCIi/h7ezO+p43xPW0cKcjnvcwNpGamsevEcQBKKypYuCmDhZsyaB0SysTEJFISk+gc2cLNlYtIU6cwIOIGUSGhPDT4Gh68eiiZh3JIzUjjg82Z5JWUAHC4IJ/XVn7Jayu/JKltOyYnJjM2oRdh/gFurlxEmiKFARE3MgwDW5t22Nq0Y/YNY/h8exapmWl8uWsHdocDgPScA6TnHGDWJ4sYGduDFFsyQ2K64GW1XvD8lZWV7N+/n5iYGGdfiog0YhqUFGkgfL28GBXfkzm338WGx3/OrOtHEdeyVc3+sspKFm3ZyO3v/p2kl55jxa4dnG+ZkE2bNjFlyhQmTZpEaGgo999/P6dOnXLFpYhII6MwINIAtQgOYcbAIXzx4KMsvf9h7uk/iGYBgTX7jxeeOe9cggMHDnDvvfeyf/9+XnzxRRYsWMA333zD3LlzXVG+iDQyGiYQacAMwyChdTQJraP5xXU38eWu7czLSKOgpOS8yxw/99xzlJWVMXfuXLp37w7A5MmT+e1vf8vMmTNdVb6INBIKAyKNhI+XF9fHxXN9XDylFRU4HI6zrmKYn5/Pf/7zH55//nliY2NrtoeFhdG8eXNycnJo27atK0sXkQZOYUCkEfI7z6uSP/30UwzD4KabbqoVFg4fPkxERMQ5l0E+cOAAaWlpfPrpp0RFRXHvvffSpk2beq9dRBoezRkQaWIWLlzIwIEDad78f8scHzhwgG3bthEZGUl0dHSdz6xfv54xY8bw29/+Fl9fX77++mu6du3Ks88+S1FRkSvLFxE3UM+ASBNimiZWq5W2bdsSEPC/NQlWrVrF3r17efjhhwGw2+0YhoHFYmHv3r08++yztGvXjkWLFtV8Zu3atRw6dAjHd484ZmdnU1ZWVmvoQUSaBvUMiDQhhmHQo0cPli5dSllZGVD1muW33nqLdu3aMX78eKDqbYvVjyXOnz+ftWvXYrFYGD16NKNHjyYtLY3+/fszYsQIgoODAfjiiy+444476NSpE48//jiHDh1yz0WKSL1TGBBpYsaPH0/z5s259957+etf/0r//v3Jycnh4YcfJiQkBKgKDdbvFi1auHAhubm5tGnThjvuuIO2bdvy+OOPk52dTWhoKFAVKK655hreeustXnrpJbZs2cL48ePZvn27265TROqPwoBIE9O9e3f+8pe/UFhYyOuvv87gwYOZO3cu11xzDatXr2bz5s01x27YsIHjx49z11138ac//YmJEyfy9NNPs2/fPubPn1/Te2CxWIiJiSEhIYEJEyawcOFCrFYrf/jDH9x0lSJSnzRnQKQJSk5OZuHChXW2P/LII7Rq1Yo5c+YQFhZGYWEhpmkyduzYmmMiIyMZNGgQ69evxzCMmu25ubmEh1etbRAQEICXlxcVFRXY7faaXgYRaZzUMyDiISorK7n//vu54YYbCAsLA6Bbt24cPHiw1s38yJEjfP311/Tp0weommwI8OGHH2KxWBg1ahQzZsxg7dq1TJ48WUFApAlQz4CIh/Dy8uLOO++s+dk0TSIiIpgxYwavv/46cXFxnDp1ipdffpmKigpmzJgBULMuwdSpU2nbti3PPvssp0+fZteuXXTs2NEt1yIi9Us9AyIeyjAMvLy8ePDBByktLSUxMbHmZUZvvPEGISEhlJWV1QwVWK1Whg0bxmuvvcZnn33G8ePH3XwFIlJf1DMg4uHi4uJYtmwZJ0+eJDs7m549e+Lr6wvAf//7X4KCgpg4cWLN8e3btyc2NpbMzEz69etX61x2h4OtRw7TqXlzgnz9XHodInL5FAZEBIDmzZvXWrUQYMeOHSxevJi0tDSmTp2K3W7n+eefp6KigmbNmtU5h9Vi4e7//JOTxUXc1D2BFFsSAzt2xnqOJZBFpGFQGBCRc/rNb35Dv379eOmll3jnnXfo2LEjx48f5xe/+AWjR4+udazd4WDd/mwO5ucB8N7GDby3cQOtQ0KZlJhEii2ZmOaRbrgKEbkQhQEROa+xY8cyduxY8vPz2bFjB7GxsTWLF32f1WIhOjSM6X378+HmTPJKSgA4XJDPH1d+yR9XfklS23ak2JIZG59IqL+/qy9FRM7BMKtXFWkC/vPVl9z60nMAvHrvg/x4zAQ3VyTimcoqK/l8exbzMtJYvnsH9u/eb1DN18uL62N7MNmWzJCYLnjp8UQRt1LPgIjUO18vL0bF92RUfE+Onylg4aYMUjPS2HbsKFAVFj7cspEPt2ykRVAwkxJ7k5KYTLeWrdxcuYhnUhgQEadqERzCjIFDuG/AYLYcOcy8jDTe35TB6eKqVyMfLzzD66u+4vVVX9GzdRum2JIZ1zORZgGBbq5cxHMoDIiISxiGQULraBJaR/PMyJv4Yud2UjPTWLZjG5XfDSNsOnyQTYcPMvvTxYzoFkdKYjLXdo3FW8MIIk6lMCAiLufj5cUN3eO5oXs8J4sK+WBTJqmZaWw+XPVa5Aq7nSVZW1iStYWIwEAm9OxNii2J+KhoN1cu0jQpDIiIWzUPDOKe/oO4p/8gth09QmpmGu9t3MCJwkIAThUV8dbar3lr7df0aBXFZFsyE3v2pnlQkJsrF2k69DSBiDQ4lXY7K3bvJDUjjc+2b6X8u5clVbNaLAzrEstkWxIjunXH10vfa0SuhP4XJCINjpfVyvBucQzvFkducTGLtmSSmpHOhoMHgKoFjpbuyGLpjizC/QMY1zORlMRkekW3qfXaZRG5OAoDItKghQcEML3vAKb3HcCuE8dJzagaRjhSkA9Abkkxb69bw9vr1tA1siUptiQm9upNq5BQN1cu0nhomEBEGh27w8GqvbuZl5HGJ1mbKa2srLXfYhgM6dyVlMRkRsb1wN/b202VijQO6hkQkUbHarEwpHNXhnTuSkFpCYu3bCI1M51v92cD4DBNlu/awfJdOwjx82NMfC9SbMkkt22vYQSRs1AYEJFGLcTPn9uS+3Fbcj+yT51kfmY68zPTOZiXC0BBaSn/SlvHv9LW0SmiOZMTk5mU2Js2YeFurlyk4dAwgYg0OQ6Hg7X79pKamcZHWzdTXF5ea79hGAzqGMNkWzI3dU8gwMfHTZWKNAzqGRCRJsdisTCwU2cGdurMb24az8dZm0nNSGN19h4ATNPk6727+Xrvbn62+H1Gx/dkcmISV7XviMVicXP1Iq6nMCAiTVqgry8ptmRSbMnk5J6uGUbYd/oUAEXlZfx3w3r+u2E97cKbMTkxicmJSbRvFuHmykVcR2FARDxG2/BmPHrNCB4ZOpz1B/YxLyONxVs2caasFIADuaf5/fLP+f3yz7mqQydSEpMYHd+TIF8/N1cu4lwKAyLicQzDoG/7jvRt35Ff3TiWT7dtJTUzjZV7dlE9jeqbfXv5Zt9efv7xB9zYPYEUWxKDOnbWMII0SQoDIuLRAnx8mNDLxoReNg7n5/Hexg2kZqSz++RxAEoqKnhv4wbe27iB1qFhTOrVmxRbMjHNI91cuUj9URgQEflO69AwZg6+loeuvoaMgzmkZqbxwaZM8ktLADicn8cfV37JH1d+SXLb9ky2JTE2PpFQf383Vy5yZRQGRER+wDAMerdtR++27Zh9/Wg+35FFakY6y3fvwO5wAJCWs5+0nP08s2QR18f2IKV3MkNiumLVMII0QgoDIiLn4eftzej4XoyO78XxMwUs3JTBvA1pbD9+FICyyko+3LKRD7dspGVwCBN72UhJTKZby1Zurlzk4ikMiIhcpBbBIcwYOIT7Bgxm85FDpGak8/6mDE4XFwFw7EwBr6/6itdXfUWv6DakJCYzrmcizQIC3Vy5yPkpDIiIXCLDMOjZug09W7fhmZE38cXO7aRmprFsxzYqvxtG2HjoIBsPHWT2p4sZ0S2OlMRkru0ai7fV6ubqRepSGBARuQI+Xl7c0D2eG7rHc7KokA82ZZKamcbmw4cAqLDbWZK1hSVZW4gIDGRCz95MsSXTI6q1mysX+R+FARGRetI8MIh7+g/inv6D2Hb0CKmZaby3cQMnCgsBOFVUxFtrv+attV/To1UUk23JTOzZm+ZBQW6uXDydXlQkIuJElXY7K3bvJDUjjc+2b6Xcbq+138ti4dousaTYkhneLQ5fL31HE9fTvzoRESfysloZ3i2O4d3iyC0uZtGWTFIz0tlw8AAAlQ4HS3dksXRHFuH+AYzrmUiKLZlerdtgGIabqxdPoTAgIuIi4QEBTO87gOl9B7DrxHFSM6qGEY4U5AOQW1LM2+vW8Pa6NXSNbMmU3slM7NWblsEhbq5cmjoNE4iIuJHd4eDrvbtIzUjnk6zNlFZW1tpvMQyGdO7KFFsyI2N74Oft7aZKpSlTz4CIiBtZLRaGdu7G0M7dKCgtYfGWTaRmpvPt/mwAHKbJ8l07WL5rByF+foxNSCQlMYmktu01jCD1RmFARKSBCPHz57bkftyW3I/sUyeZn5nO/Mx0DublAlBQWsq767/h3fXfEBMRyWRbEpMSk4gODXNv4dLoaZhARKQBczgcrN23l9TMND7aupni8vJa+w3D4OpOnZmcmMSN3RMI8PFxU6XSmKlnQESkAbNYLAzs1JmBnTrzm5vG83HWZlIz0lidvQcA0zRZuWcXK/fs4snF7zM6vicptmT6teuARS9NkoukMCAi0kgE+vqSYksmxZZMTu7pmmGEfadPAVBUXsZ/N6znvxvW0y68GSmJSUy2JdMuvJmbK5eGTmFARKQRahvejEevGcEjQ4fz7YF9pGaksWjLRgrLygA4kHual5Z/zkvLP+eqDp2YYktmVI8Egnz93Fy5NEQKAyIijZhhGPRr35F+7TvyqxvH8um2raRmprFyzy6qp4R9s28v3+zby1Mfvc+N3ROYYktmYMcYDSNIDYUBEZEmIsDHhwm9bEzoZeNwfh7vbdzAvIw09pw8AUBJRQXvbdzAexs30Do0jMmJSaTYkugUEenmysXdFAZERJqg1qFhzBx8LQ9dfQ0ZB3NIzUzjg02Z5JeWAHA4P49Xv/qCV7/6guS27UmxJTMmvheh/v5urlzcQWFARKQJMwyD3m3b0bttO2ZfP5rPd2SRmpHO8t07sDscAKTl7CctZz+/WPIhN8TFM9mWxJCYrlg1jOAxFAZERDyEn7c3o+N7MTq+F8fPFLBwUwbzNqSx/fhRAMoqK/lgcyYfbM6kZXAIk3r1ZrItmW4tWrq5cveyO0yyTxay90QRpZUOSivsGICvt5UAbysxLYJo3ywAi6XxrgipMCAi4oFaBIcwY+AQ7hswmM1HDpGakc7CTRvILS4G4NiZAv68agV/XrWCxOi2pNiSGJuQSLOAQDdX7nzHz5SyevdJNh8sIDMnl62HCyirdJz3MwE+VhKiQ+nVNoz46FAGd2lOWEDjWQBKKxCKiAgA5ZWVfLFzO6mZaSzbsY1KR+0boLfVynXdupNiS+aaLt3wtlrdVGn9M02Tb7NPM2ftfj7ZcgSHCV4Wg0rHpd0iqz/jbTUYm9iaqVd1oFfbMOcUXY/UMyAiIgD4eHlxQ/d4bugez8miQj7YlElqZhqbDx8CoMJu5+OszXyctZnmgUFM6GUjJTGZHlGt3Vz55SutsDM/LYe31+xj74kirBaD6vv/pQaB73+mwm7yfsZhFqQfonvrEO4Y0IFxidH4eDXMeRjqGRARkfPadvQIqZlpvLdxAycKC+vsj2/Vmsm2ZCb0tNE8KMgNFV6etH2neWReJgdzq56wcNbN0DDANKFryyBemZJIj9ahTmrp8ikMiIjIRam021mxeyepGWl8tn0r5XZ7rf1eFgvDusYyOTGZEd3i8PFqmJ3PJeV2Xlq6g3+sysYw4DI6AC6L1TAwMfnxsC48MLRzg+olaJh/UyIi0uB4Wa0M7xbH8G5x5BYXs2hLJqkZ6Ww4eACASoeDz7Zn8dn2LML9Axjf08ZkWxK9WrfBMBrGTPv0/bk8/N8MDuWVYFL1jd1V7N819uqyXSzZfIRXb7YRFxXiugLOo0n1DLy/dhUP/OVVAH51253cM/JGN1ckItL07TpxnNSMqmGEIwX5dfZ3a9GSFFsyE3v1pmWw+25+n209yoP/3oDDNF3WG3AuVouBt9Xg7Tv60j8mwr3F0MTCgIiIuI/d4eDrvbtIzUjnk6zNlFZW1tpvMQyGdu5Gii2JkbE98PP2dllt72cc5LHUjZim8+YGXCqLARaLwZtTk7g21r1rOSgMiIhIvSsoLWHxlk2kZqbz7f7sOvtD/fwZk9CLlMQkktq2d+owwiebj/DA3A0uHRK4WAZVvQRz7urLgM7N3VeHwoCIiDhT9qmTzM9MJzUjjUP5eXX2x0REMtmWxKTEJKJDw+q17dW7TzLtH9/icJgNpkfghywGeFstLJgxgIQ27nnSQGFARERcwuFwsHbfXlIz0/ho62aKy8tr7TcMg6s7dWZyYhI3dk8gwOfKVvDLKy7n2t9/RW5xeYPsFfg+iwFtwgNY+shg/Lxdv5iTwoCIiLhcUVkZH2dtZl5GGmuy99TZH+Try+gePZlsS+aq9h0vaxjh4XmZLMo85PbJghfLMOCeQR35+U3dXd+2woCIiLhTTu5p5memMz8znX2nT9XZ3z68GZMTk5hsS6ZdeLOLOueyrGPcMyetvkt1OgNYcH9/ktpf3HXWW7sKAyIi0hCYpsm3B/aRmpHGoi0bKSwrq3NM/w6dSLElM6pHAkG+fmc9T2MaHvghdw0XNNkwUFFRwcmTJwFo3rw53i58hEVERK5McXk5n27bSmpmGiv37OKHtyp/b29u6p7AlN59GNChExbL/1bz+/VHWby9el/NIj+NjWHAEyNjuX9ojOvabGphIDU1lZdffpn09HTs3y2VabVaSUpK4pFHHmHKlClurlBERC7F4fw83tu4gXkZaew5eaLO/ujQMCYlJpFiSyIquBnJz31OUZn9LGdqPFqF+LH6yWuxWlyzcmOTCgOvv/46jz/+OPfeey/Dhg2jZcuqRRyOHTvGF198wRtvvMHvf/97HnzwQTdXKiIil8o0TTIO5pCamcYHmzLJLy2pc0xMWA8Onoh0Q3X17+/TkxkW55rFiJpUGOjQoQO//OUvmTZt2ln3z5kzh1mzZpGdXXcBDBERaTxKKyr4fEcW8zLSWLF7J3aHA0zwrkzGIBCDhvEuhMtltRgMjIlgzt39XNJekwoD/v7+ZGRkEBsbe9b927dvx2azUVJSN02KiEjjdPxMAQs3ZTDnmy0cPtHB3eXUGwNY8dOhtI8IdHpbDef9ifUgMTGRV155pc5EE6jqXnrllVfo1auXGyoTERFnaREcwoyBQ7ih2zUuG2N3BcOAJZuPuqStJvUK49dee42RI0eyZMmSOnMGli1bRnFxMZ999pmbqxQREWfYmJOH3ckrDJ3Z8DGnP/8LPlFdiZr2slPbAth0MM/pbUATCwPJycls376dd955hzVr1rBjxw4AWrVqxY9//GPuuusumjd334sgRETEORwOky2H674+ub4VZa3AGtqS8iM7qcg9jHd4a6e15TAhIyfPaef/viYVBgAiIyP56U9/6u4yRETEhfaeLKK0wuHUNiryjlJ2aBuR45/i1Gd/pmjrCsIG3erUNo/ml5JXXE5YwJW9p+FCmtScgWuvvfacTxKIiEjTteWQa3oFLH5B+Mf0IaDbQIqyVji9TYAthwqc3kaTCgMdOnSgTZs27i5DRERcbMexM3g5efJg0dYVBHQdgGH1JjBuMJW5hyk7stOpbVoM2H7U+WGgSQ0T/OMf/3B3CSIi4gZFZZVOPX/Z0d1Unj5IwIgZAPi26YE1uDlFW1fgG9XVae1aDMMlqyk2qZ4BERHxTKUVzr1hFm1djiUwDL92CQAYhkFg7NUUbV+J6XBe24YBpZUKA5fE4XDw7LPPkpyczODBg1mxYgUA//nPf5g5cyZz5851b4EiIuIU9qoFCJ3CdNgp3v41fu16Upl/jIrcw1TkHsandTccRXmU7t/opJarOJz8uCQ0sWGC5557jldeeYX7778fh8PBLbfcwlNPPcWsWbNISkrib3/7G8ePH+fhhx92d6kiIlKPfL0tTluAuHT/JuyFpynetpLibSvr7C/KWoF/x95Oads0wdfL+d/bm1QYePfdd3njjTdq3kwYGxvLjBkzWLVqFX369GHevHnMmjVLYUBEpInx87LirDRQlLUCS0AYzb6bL/B9xTvXUrxzLY7ryrB4+9Z72ybg622t9/P+UJMKA4cOHaJfv/+91KFv376YpkmfPn0A6N+/PwcOHHBXeSIi4iRtwv2dsvqgo6KM4p1rCOg2iMDYQXX2W4MiKN72FSW71xEYN7je27c7TNo2C6j38/5Qk5ozEBkZya5du2p+3r17N3a7nb179wKwc+dOrUAoItIEJbQJxRmv3SvZvQ6zvISALmd/e6BvdDcsAaFOXXMgITrUaeeu1qR6BsaMGcMDDzzAL3/5SxwOB0899RQzZsxg1KhR3HjjjfznP/+pGUIQEZGmo3tUCAb1P4mwKGsFhpcPfh0Sz7rfMCz4d+pDUdYK7CUFWP1D6rV9fx8r7V3QM9CkXmFcUFDAjBkzWLRoEQBPPvkkTz/9NM8//zwff/wxffv25bnnnsPXt/7HdURExL2GvricfaeK3V1GverbIZzUGQOc3k6TCgPVTNPEMJrOayxFROTCHp2XyYcbDzv9zYWu4mUxuHNgB35+U3ent9Wk5gxU+2EQKCwspLS01E3ViIiIKwzo3LzJBAGASofJgM6umefWpMLA/PnzWbp0ac3P2dnZDBw4kJCQEIKDg5kyZQqFhYVurFBERJxlVM8ognybzlS4qFA/BneJdElbTSoM/OxnP+P7ox533XUXvr6+fPHFFyxevJisrCyefvppN1YoIiLO4udt5Za+bbE6+YVFrmAxYPqADi67liY1Z8Df359t27bRoUMHSkpKCAwM5NChQ0RFRQGwevVqbrvtNvbt2+feQkVExCn2nSxi6Esr3F3GFfOyGHz78+E0C/RxSXtNqmegWbNmNesMFBQU4OXlRcuWLWv2R0VFcfz4cXeVJyIiTtaheSCDOjfH2og7B6wWg9G9WrssCEATCwOTJk3iiSeeIDc3l5YtW9K7d+9aLyd699136d3bOetHi4hIw/CT4V1o7PMI7x8a49L2mtQwwZkzZ7j++uvJyspi5MiR+Pj4MHfuXPr3709JSQm7d+9m2bJlJCcnu7tUERFxotmLtjJn7b5GGQoev64rD13bxaVtNqkwAGC323nnnXf44IMP2Lt3Lw6Hg6ioKAYNGsT9999fM39ARESaruLySka8vJKj+SXYG8ldzmox6NYyiEUPDcLL6tqO+yYXBkRERADW7T3FlDe/cXcZF81qMVjy46vp1irY5W03qTkDIiIi1fp1iuDuQR2d9WbjevfYdV3dEgRAYUBERJqwn90Qy4geLWnoSw/c0rct9w9x7aTB72tSwwQOh4NKhx0Aq8WK1aKsIyLi6coq7dz9Thpr9pxscBMKDeCmnlG8erPNrYslNakwsHlfNu+tWQnADUl96dctzs0ViYhIQ1BWaeehuRksyzpW7685vhIpyW347YSebl81seks4gxs2Z/Ns/+ZA0CzoGCFARERAcDXy8pfbuvNMx9uZe63B7AYuK2XwPpd2w9cE8Pj13VrEG/ZVT+6iIh4BC+rhd9MSODtO/rQLNDHLfMILAZEhfkz777+/HRkbIMIAqAwICIiHuaa2BZ88dhQJvRuA+CSUGAxquYH3DGgI58/MoS+HZs5v9FL0KSGCURERC5GqL83L03uxU09o/jtkm3sPFaI1WJgr+exg+pzxkeH8vRN3RtcCKimMCAiIh7rmm4tGNo1kg0H8nh37T4+2nQEu2lyJVPrqzsafLwsTOgdzW392hMfHVov9TqLwoCIiHg0wzBIah9OUvtwnh7VndS0HJZlHSPrSAGlFQ6g6pXClefoNfj+vgAfKwnRoVzXoxWTktoQ6u/tsuu4EgoDIiIi32ke5MsDQzvzwNDO2B0m2SeL2HIon82H8tlzopDicjsl5XYsBvh5Wwn09aJLiyDio0NJiA6lXbMALA19haOzUBgQERE5C6vFoHOLIDq3CGKcLdrd5TiVniYQERHxcAoDIiIiHk5hQERExMMpDIiIiHg4hQEREREPpzAgIiLi4RQGREREPJzCgIiIiIdTGBAREfFwCgMiIiIeTmFARETEwykMiIiIeDiFAREREQ+nMCAiIuLhFAZEREQ8nMKAiIiIh1MYEBER8XAKAyIiIh5OYUBERMTDKQyIiIh4OIUBERERD6cwICIi4uEUBkRERDycwoCIiIiHUxgQERHxcAoDIiIiHk5hQERExMMpDIiIiHg4hQEREREPpzAgIiLi4RQGREREPJzCgIiIiIdTGBAREfFwCgMiIiIeTmFARETEwykMiIiIeDiFAREREQ+nMCAiIuLhFAZEREQ8nMKAiIiIh1MYEBER8XAKAyIiIh5OYUBERMTDKQyIiIh4OIUBERERD6cwICIi4uEUBkRERDycwoCIiIiHUxgQERHxcAoDIiIiHk5hQERExMMpDIiIiHg4hQEREREPpzAgIiLi4RQGREREPJzCgIiIiIdTGBAREfFwCgMiIiIeTmFARETEwykMiIiIeDiFAREREQ+nMCAiIuLhFAZEREQ8nMKAiIiIh1MYEBER8XAKAyIiIh5OYUBERMTDKQyIiIh4OIUBERERD6cwICIi4uEUBkRERDycwoCIiIiHUxgQERHxcAoDIiIiHk5hQERExMN5ubuAS5VXWEheUeFZ953Iz6v571NnCth37OhZjwsJCKBZcIgzyhMREWl0DNM0TXcXcbH+89WXTHvld1Ta7Vd0HovFwqv3PshDo8bVT2EiIiKNWKMaJliVtfmKgwCAw+Fg5ZZN9VCRiIhI49eowsCtQ4bV27luG1p/5xIREWnMGlUYGNg9nhGJSVd8nsROnRnTb0A9VCQiItL4NaowADDrlmlXfI7Zt0zDMIx6qEZERKTxa3Rh4Ep7B9QrICIiUlujCwNwZb0D6hUQERGprVGGgcvtHVCvgIiISF2NMgzA5fUOqFdARESkrkYbBi61d0C9AiIiImfXaMMAXFrvgHoFREREzq5Rh4GL7R1Qr4CIiMi5NeowABfXO6BeARERkXNr9GHgQr0D6hUQERE5v0YfBuD8vQPqFRARETm/JhEGztU7oF4BERGRC2sSYQDO3jugXgEREZELazJhYGD3eBLad6z5OTqiuXoFRERELkKTCQMAv7r9zpr/fmryreoVEBERuQiGaZqmu4uoT6uztlBSXsbwK3izoYiIiCdp3GGgogSOboEjmXByJ5QXQ2UpYIKXP3j7QURniEqEVgngG+TmgkVERBoeL3cXcEnslbDrM9i+BA6uh1O7wHQABli8APO7nwHDUrXdtFdtMwwI7wRt+kCXERA3Brx83HgxIiIiDUPj6BkoPA4b/gnf/g0Kj1bd+B2Vl3cuixUcdvBvBn3uhqQ7ILRNvZYrIiLSmDTsMHBqD3z5a9j2IZjf+9ZfXwxr1Tm7Xg/XPg2t4uv3/CIiIo1AwwwDDges+yssm1X1Ld60O7c9wwoGMORJGPQIWL2d256IiEgD0vDCwKk98P4MOPitGxo3oEV3mPCmeglERMRjNKwwkPY2fPJEVU+Aw8m9AedS3Utw7S9g4MNVEw9FRESasIYRBkwTvnoBVvzG3ZXU1m8GjPwtWJrU2kwiIiK1uD8MmCZ8/gys+aNbyzinxNthzGsKBCIi0mS5/w638qWGGwQAMv8Fn/2sKrSIiIg0Qe4NAxn/huW/dmsJF2XdXxt2YBEREbkC7hsmyDsAf+oLlSVuaf6SWaxw3ypo2d3dlYiIiNQr9/QMmCZ8+CA4yt3S/GVb+KOqJZFFRESaEPeEgfR3IHul+x4fvBwOOxzbDKv/4O5KRERE6pXrhwnycuBPfRrP8MAPabhARESaGNf3DKx6BRwVLm+2Xq34nbsrEBERqTeuDQOlBZA59/LfONgQOOyw/SMoOOLuSkREROqFa8PApnlQWerSJp3DhA1z3F2EiIhIvXBdGDBNWPeGy5pzKtMB698CeyMf7hAREcGVYWD/Gji1C2giK/kVnYAdn7i7ChERkSvmujCw+3OweLmsOaezeFVdk4iISCPnurvzoQ1OX1dgz2kHL6wu4/O9lRw+Y+JjhYSWVlK6e/GjJB/8vevxdcSOSjiYVn/nExERcRPXhAHThMMbcOYQwcc7K5g8vwRfL5jW04f4FhbK7bAqp5Kffl7G1hMO3hztX7+NntwBFaXg7Ve/5xUREXEh14SBvANQdsZpp8/OdXDzeyW0D7Pw5bQAooL/N/rxYF8fdl/j4OOdTpjs57DD8a0QnVT/5xYREXER18wZOJLp1NO/sLqMwnL4+xi/WkGgWudmFn5yla8TWjbgcKYTzisiIuI6rgkDp/ZULePrJIt3VtIp3GBAWxdPULR4wem9rm1TRESknrkmDFSUOK2pgjKTQ2dMElo4L2ycV0UjfceCiIjId1wTBpy46mBBWdWkxGDfenxS4KKZTWRFRRER8WSuCQOG827UId+FgDNlblrMyInXJiIi4gquCQNe9fxI3/eE+Bq0DjbYcty5axicneHUaxMREXEF14QBn4Cq9fydZFQXL/bkmqzNccPbEL0VBkREpHFzTRho3g1M531zf2KgL4HecM/iUo4V1g0de047ePWbsvpv2FEBkbH1f14REREXcs2zeK0TnXr6mGYW5k70Z8qCEuL+XMi0Xv9bgXBNjp35WRXc0cvbOY07+dpERESczTBN0zUz716IgeKTTm1i1yk7L64pr3k3ga8Vera0cnO8N/f29sbXq54n+1l94KkjYG1CL2ASERGP47q7WHQy7F7q1LkDXSKs9f/+gfNp2UNBQEREGj3XvcI42gY0ocfwLF5VAUdERKSRc10YiL3JqZMIXc5RCXGj3F2FiIjIFXNdGGiVUPVN2nBdk85jQHhH6DjE3YWIiIhcMdfemfvd59Q5Ay7V7z6tPigiIk2Ca8NA97HgF+bSJp3C6g29bnF3FSIiIvXCtWHAyxeS7wTDTW8YrA+GFXreDP5h7q5ERESkXrh+AH/Aj7+7kTbSuQPefjD0SXdXISIiUm9cf0cOaAZj/ww00rkDN7wAodHurkJERKTeuOfrebcboOeUxjVcYFghZhgk3ubuSkREROqV+/rqr//dd8MFjWRGvpcvjHlNTxCIiEiT474wENAMJrzVeG6uY17T8ICIiDRJ7p3F13kYjH+DBt87cP3zkDDJ3VWIiIg4hfun9PdMgVGv0GADwbBn4KoZ7q5CRETEaVz3CuML2TQf3v9R1X+7fZVCAzDhxpeg771urkVERMS5Gk4YANjzJSz8ERSfdt9LjQwr+AbBmD9B9zHuqUFERMSFGlYYACjJhU+fgo1zq15q5LJegu96A2JHVQ1bBLVwUbsiIiLu1fDCQLWdn8GHD0LxKecHguregFGvQI8JjecJBxERkXrQcMMAQEkerP0zpP29KhQY1vobPqjudfANgaTpVcskqzdAREQ8UMMOA9XsFbD9I1j3BhxY+7+VCy81GBgWwKj6XJSt6jXEPcZXvW9ARETEQzWOMPB9x7fDjiVwOBMOrYeCw1XbDcv/bvYAmFXf/KuHGIJaQnQytLZBlxHQOtH1tYuIiDRAjS8M/FDxaTiyEU7uhPIiqCwDTPDyA29/iOgCUb0gKNLdlYqIiDRIjT8MiIiIyBVx/wqEIiIi4lYKAyIiIh5OYUBERMTDKQyIiIh4OIUBERERD6cwICIi4uEUBkRERDycwoCIiIiHUxgQERHxcAoDIiIiHk5hQERExMMpDIiIiHg4hQEREREP9//fvsFEhKKf9QAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "filename = \"models/M1C.csv\"\n", + "ds = Reader(filename)\n", + "ps = prob.ProbSpace(ds.varData, categorical=['A', 'B', 'C'])\n", + "cmodel.show(probspace=ps, targetSpec=['A', 'B', 'C'], sensitivity=10, power=5, edgeLabels='rho', verbosity=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Test model: M1C (shrinking chain)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "ExecuteTime": { + "start_time": "2023-08-09T03:17:13.327079Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "getData: 10000 records read.\n", + "\n", + "\tTesting A -> B direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 0.30783248182335754 \n", + "Backward:0.0\n", + "Rho-value: 0.30783248182335754\n", + "identifiable: True\n", + "\n", + "\tTesting B -> C direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 0.48319091634898104 \n", + "Backward:0.0\n", + "Rho-value: 0.48319091634898104\n", + "identifiable: True\n", + "triangles = [('B', 'A', 'C')]\n", + "Map = \n", + " A --> B ( 0.308 )\n", + " B --> C ( 0.483 )\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "filename = \"models/M1Cv2.csv\"\n", + "ds = Reader(filename)\n", + "ps = prob.ProbSpace(ds.varData, categorical=['A', 'B', 'C'])\n", + "cmodel.show(probspace=ps, targetSpec=['A', 'B', 'C'], sensitivity=10, power=5, edgeLabels='rho', verbosity=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Both versions of the model seem to predict accurately; the shrinking cardinality maybe slightly less." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Test model: M2 (Common cause model)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "ExecuteTime": { + "start_time": "2023-08-09T03:17:13.338575Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "getData: 10000 records read.\n", + "\n", + "\tTesting A -> B direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 0.0 \n", + "Backward:0.3866921299925631\n", + "Rho-value: -0.3866921299925631\n", + "identifiable: True\n", + "\n", + "\tTesting A -> C direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 1.9089095859570193e-09 \n", + "Backward:0.0\n", + "Rho-value: 1.9089095859570193e-09\n", + "identifiable: False\n", + "triangles = [('A', 'B', 'C')]\n", + "Map = \n", + " A --> C ( 0.0 )\n", + " B --> A ( 0.387 )\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "filename = \"models/M2.csv\"\n", + "ds = Reader(filename)\n", + "ps = prob.ProbSpace(ds.varData, categorical=['A', 'B', 'C'])\n", + "cmodel.show(probspace=ps, targetSpec=['A', 'B', 'C'], sensitivity=10, power=5, edgeLabels='rho', verbosity=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Predicts B->A only. (Sometimes did other predictions correctly on different generations, but was not consistent)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Try testing with subspace and conditioning to see if there are different results." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "ExecuteTime": { + "start_time": "2023-08-09T03:17:13.351465Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\tTesting B -> C direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 0.6093759055292958 \n", + "Backward:0.0\n", + "Rho-value: 0.6093759055292958\n", + "identifiable: True\n", + "triangles = []\n", + "Map = \n", + " B --> C ( 0.609 )\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ss = ps.SubSpace([('A', 0)])\n", + "cmodel.show(probspace=ss, targetSpec=['C','B'], sensitivity=10, power=5, edgeLabels='rho', verbosity=1)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "ExecuteTime": { + "start_time": "2023-08-09T03:17:13.360638Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\tTesting B -> C direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 0.5287968457176331 \n", + "Backward:0.0\n", + "Rho-value: 0.5287968457176331\n", + "identifiable: True\n", + "triangles = []\n", + "Map = \n", + " B --> C ( 0.529 )\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ss = ps.SubSpace([('A', 1)])\n", + "cmodel.show(probspace=ss, targetSpec=['C','B'], sensitivity=10, power=5, edgeLabels='rho', verbosity=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "ExecuteTime": { + "start_time": "2023-08-09T03:17:13.370864Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\tTesting B -> C direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 0.962598723657692 \n", + "Backward:0.0\n", + "Rho-value: 0.962598723657692\n", + "identifiable: True\n", + "triangles = []\n", + "Map = \n", + " B --> C ( 0.963 )\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ss = ps.SubSpace([('A', 2)])\n", + "cmodel.show(probspace=ss, targetSpec=['C','B'], sensitivity=10, power=5, edgeLabels='rho', verbosity=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Conditioning on A seems to yield B->C" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "ExecuteTime": { + "start_time": "2023-08-09T03:17:13.379217Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\tTesting A -> C direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 0.8495545095223188 \n", + "Backward:0.0\n", + "Rho-value: 0.8495545095223188\n", + "identifiable: True\n", + "triangles = []\n", + "Map = \n", + " A --> C ( 0.85 )\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGdCAYAAACPX3D5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAsNklEQVR4nO3deXiU1cH38d9M9gVCCAkJCSTsAQFBRNkULJtaQEBksZBAfRS0Yiu2Si2yWK1WW5HWrWgFqfK8CC222PiIUhAFF1AUFAEhJIYlQAIJMNkn5/0DkxISlpDMJOF8P9dFr4uZueecCbHznXMv4zDGGAEAAGs563oCAACgbhEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRA6hV7733nqZOnaoOHTqocePGCggIUExMjIYMGaIFCxbo6NGjdT1Fj1uyZIkcDoemTJlSre0cDkelP0FBQUpISNCECRP00Ucf1eo8y8bwlkv9udS1hIQEORwOpaWlVWu7KVOmyOFwaMmSJR6ZF1CbiAHUiqysLA0ZMkRDhw7VkiVLVFxcrBtuuEG33nqrOnXqpE2bNmnmzJlq06aNPv3007qebr02bNgwJScnKzk5WYMGDVJBQYGWL1+u66+/XgsXLqzr6VUpLS1NDodDCQkJdT0VAJfAt64ngIYvNzdX/fv3165du5SYmKhFixbpuuuuq/CYwsJCvfbaa5o7d64OHTpURzNtGGbNmqWBAweW/z0vL0+TJ0/WP/7xDz344IMaO3asYmNj626Cl2j06NHq3bu3wsLC6noqXvHEE09o1qxZiomJqeupABfEygBqbMaMGdq1a5cSEhK0cePGSiEgSQEBAbrrrrv05ZdfqlOnTnUwy4YrODhYf/7znyVJRUVFevfdd+t4RpcmLCxMiYmJ1rw5xsTEKDEx0Zr4QcNGDKBGUlNTtWzZMknSM888o6ZNm5738c2bN1fHjh3L/37y5Em9/PLLGjNmjNq3b6+QkBCFhISoa9eu+s1vfqOcnJwqn+dC+7sHDhwoh8Oh9evXV7g9NzdXs2fPVteuXRUSEqKAgAC1aNFC/fr105w5c1RcXFzh8e+//75mzJih7t27q1mzZgoICFBcXJzGjx+vzZs3n/e11qYWLVooIiJCknT48OEqH7Ny5UrdeOONioyMlL+/v2JjYzVp0iTt2LGjWmPt2LFDc+fOVb9+/RQbGyt/f39FRERo8ODBevPNNys9fsqUKWrdurUkKT09vdJxD2UudMzAZ599pnHjxqlFixby9/dXVFSURowYoffee6/Kx5+5T37fvn2aPHmyoqOjFRAQoLZt22r27NkqLCystF1paakWLVqkfv36qUmTJvLz81NUVJSuvPJKzZgx47zHBqxbt05Dhw5VeHi4goKCdNVVV2np0qUXnN+Z5s2bJ4fDoXnz5ik9PV1JSUmKiYlRYGCgOnTooHnz5ik/P7/K51yxYoUGDx6siIgI+fn5KSIiQp07d9add96pbdu2nXPewAUZoAYWLlxoJJkmTZqYkpKSam//4YcfGkkmMjLS9O/f34wfP94MHTrUREREGEmmXbt2Jisrq9J2ksz5fn0HDBhgJJl169aV3+ZyuUyXLl3KxxsxYoSZMGGCGThwoImOjjaSzPHjxys8T9u2bY2/v7/p0aOHGTlypBkzZozp3LmzkWR8fX3NypUrK429ePFiI8kkJydX62dR9prOnHMZt9ttAgICjCTz17/+tcJ9xcXFZty4cUaSCQgIMH379jW33XabufLKK40kExQUZN55551zjne2O+64w0gyiYmJZtiwYWb8+PGmT58+xul0Gknm/vvvr/D4l19+2dx6661GkgkJCTHJyckV/lzMz2XRokXlz9+jRw8zceJE07dv3/I5zps3r9I2ycnJRpL5+c9/bho3bmzi4+PNuHHjzODBg01QUJCRZEaNGlVpu6lTpxpJJjAw0AwePNhMnDjRDBs2zLRv395IMqtWrarw+Pj4eCPJPPLII8bhcJiePXuaCRMmmN69e5fPb8GCBeec3+LFiyvcPnfuXCPJJCUlmYiICNO8eXNz2223meHDh5uQkBAjyfTr18/k5+dX2G7+/Pnlv3fXX3+9mThxorn55ptNly5djMPhqHIOwMUiBlAjkydPNpLMj370o0vaPiMjw7z//vvG7XZXuN3lcpmkpCQjydxzzz2VtruUGHjttdeMJHPTTTeZoqKiCo93u91m/fr1prCwsMLtq1atMseOHav0/KtWrTK+vr4mIiLC5OXlVbjPEzGwZs0aI8n4+/ubAwcOVLjv4YcfNpLMtddea1JTUyvct2LFCuPj42PCw8Mrhc65fobr1683e/furXT7zp07TVxcnJFkPv300wr37du3z0gy8fHx53x95/q5bNu2zfj6+hqHw2GWLl1a4b6UlBTj7+9vJJk1a9ZUuK/szVaS+c1vflMhRrdv317+xrpp06by29PT040kExcXZw4dOlRpjjt27DDp6ekVbiuLAT8/P7N69eoqX1NYWFil34MLxYAkc8stt1TYLiMjw3To0MFIMrNmzSq/vaCgwAQFBZnQ0FCzc+fOSvNOS0sz3377baXbgYvFbgLUSNmpglFRUZe0fVxcnAYNGiSns+KvYnBwsF588UX5+vpqxYoVNZ6n9N/l9SFDhsjPz6/CfU6nUwMGDJC/v3+F20eNGqXw8PBKzzVq1Cjddtttys7O1rp162plflXJysrSypUrNWXKFDmdTj333HNq0aJF+f3Hjh3TggULFBgYqL///e/ly/Vlxo4dq2nTpun48eN6/fXXL2rMAQMGqE2bNpVu79ixox555BFJp3dJ1JaFCxeqpKREo0eP1uTJkyvcd9NNN+muu+6SJD399NNVbt+zZ0/99re/lY+PT/ltXbp0KX+u999/v/z2st+Bq666StHR0ZWeq1OnTmrVqlWV48yYMUPDhw+vcNuUKVOUmJio3Nxcbdmy5UIvtYKgoCC99NJLCgoKKr8tLi5Of/zjHyVJL7zwggoKCiRJJ06cUH5+vtq0aVNhN1uZ+Ph4JSYmVmt84EycTYB6YdOmTfrwww/1/fffKy8vT8YYSZK/v7+OHj2q48ePV/mmXB29evWSJD311FOKiIjQ8OHDL3iMgyQdPHhQ//73v7Vz507l5uaqpKREkvTNN99Iknbt2qWbb765RnM70w033FDptqCgIK1Zs0aDBg2qcPu6deuUn5+vQYMGnfMMg4EDB+qFF17Qpk2bdO+9917UHE6dOqV33nlHW7duVVZWloqKiiSp/EyQXbt2VeclnVfZcR3nOpbgjjvu0HPPPacPP/xQbre7wpu+JA0fPrzK40fKDlQ9cOBA+W2JiYlq1KiRUlJS9Pjjj+v222+vFFDnMmLEiCpv79Spk3bu3FlhnIsxdOjQKoNk+PDhioiIUHZ2tr744gv17dtXkZGRSkhI0LZt2/TAAw/ojjvuUOfOnas1HnA+xABqJDIyUpJ05MiRS9r+yJEjuvXWWy94QZ0TJ07UOAYGDhyohx56SE8//bSSk5PlcDjUvn179evXT7fccotGjBhRaYVi/vz5evzxxysdWHj23GrTsGHDFB0drdLSUmVmZmrDhg3Kz8/XpEmTtHHjxgqf2lNTUyVJa9euveAFhC72gk+rV6/W1KlTlZ2dfc7H1OZrLnsTPdebctu2bSVJBQUFys7OrrQKda5P8o0bNy7frkyjRo20ePFiTZ06VbNnz9bs2bMVExOj3r1768Ybb9Ttt9+u0NDQKp+vOuNcjPNFSEJCgrKzs7V///7y25YuXaqxY8fqmWeeKT9Y99prr9WQIUM0efJkNWvWrFrjA2diNwFqpGfPnpKkL774Qm63u9rb/8///I8++ugj9enTR2vWrNHhw4dVVFQkc/p4lvLT0MpWCi5WaWlplbc/+eST2rt3r/70pz/ptttuk8vl0uLFizVq1Cj17t1bLper/LH/+Mc/NG/ePAUEBOgvf/mLvvvuO7lcLpWWlsoYo1//+teXNLcLmTVrlpYsWaKlS5dqzZo1Sk1NVZcuXZSZmanbb7+9wnhlr7Ndu3blFyo615+zVxWqcuDAAY0fP17Z2dl68MEH9dVXXyk3N1dut1vGmPLTGmv7NdfE2QF3IbfeeqsyMjK0dOlS3XnnnQoPD9eqVas0bdo0tWvXTtu3b6+VcWrDmT/n6667TmlpaVqxYoXuvfdeJSQk6N133y2/mNfatWu9Pj9cPlgZQI0MHz5cM2fOVE5Ojv71r39p9OjRF72ty+VSSkqKnE6nUlJS1KRJk0r3Z2ZmVrmtn5+fiouLdfLkSTVq1KjS/enp6eccNyEhQTNmzNCMGTMkSZs3b9akSZO0efNmPfXUU5o/f74klZ9G9/jjj5fvtz7Td999d1Gvs6ZatGihFStWqFu3bvr000/1xhtvaNKkSZKkli1bSjq9P782Lnu7evVq5efna/To0fr9739f6X5PvObY2Fjt3bu3PHrOVrb6ERgYeFG7dS5GWFiYJk+eXH5cQUZGhmbMmKF//vOfuvfee/XBBx/Uyjjns2/fvnPeV3Z6Y1xcXIXbg4KCNHbsWI0dO1bS6dWe2bNna9GiRfrpT3963t974HxYGUCNtG3bVhMnTpQkPfDAAzp27Nh5H3/kyJHy/c1lnzgbN25cKQQk6fXXXz/nJ9Cy/ePffvttpfu2bdumjIyMi34NvXr10j333CNJ+vLLL8tvL3st8fHxVb6Oc53/7gmJiYm6++67JZ0+T73suIVBgwbJ399f69evv+RdNWc632s2xpRfU+JsZQdels2rOsqutniumHn11Vclnf5k7Ovrmc8vLVu2LI/AM38HPGnNmjVV/pulpKQoOztbjRo1Kl95O5fIyEg99dRTkqTvv/9ex48f98hccfkjBlBjf/7zn9WuXTvt27dP/fv3r3L/f1FRkV599VX16NGj/A28efPmCg8PV05Ojv72t79VePwnn3xSvgxflcGDB0s6vU//zAvLpKWlKTk5ucqIWLVqlTZs2FBpF0JxcbH+7//+T1LFN8GyA9AWLVpUfgCddDpikpOTlZube875ecLs2bMVGhqqvXv36rXXXpN0+mc4Y8YMuVwujRgxosol7sLCQv3rX//Szp07LzhG2WteuXJlhctGu91uzZkzR5s2bapyu7ILHWVmZl4wCM/285//XL6+vnrrrbcqnfGwZs0a/eUvf5Ek/fKXv6zW81Zl69atWr58eZUX9Vm9erWkqkPIE/Lz83X33XdXmMvBgwf1wAMPSJKmT5+uwMBASadXul555ZUqj9Uom3d4eHj58QtAdbGbADUWHh6ujRs3avz48Vq/fr2uu+46tW7dWt26dVNwcLAOHz6szz77TKdOnVLjxo3LT43z8fHRnDlzdP/99yspKUnPP/+82rRpo++//16bNm3SpEmTtGHDhiqXPh9++GGtXLlSKSkp6tChg3r16qWjR49q8+bN6tevn/r27VvpjeuDDz7QwoUL1axZM/Xo0UNRUVE6efKkPvnkEx05ckSxsbF68MEHyx//i1/8QkuXLlVKSoratGmj3r17q7i4WB988IGCg4P105/+tPxTqzdERkZq5syZevTRR/XYY48pKSlJfn5+evLJJ3Xo0CEtW7ZM3bt315VXXqk2bdrI19dX+/fv15dffimXy6V33nnngqefjRgxQj179tTnn3+uDh06aMCAAQoJCdGnn36qgwcP6qGHHqpy94Gfn59GjhyplStXqnv37urfv7+Cg4MlSa+88sp5x+zatauef/553X333Zo8ebIWLFigxMREpaena9OmTTLGaN68eRo6dOil//B+kJ6ergkTJpRfPbBly5YqKSnR9u3btWvXLvn7+5d/0va0pKQkvf3222rTpo2uu+46FRQU6D//+Y9cLpf69OlTvlIhScePH9edd96pe+65R927dy8/+PC7777T1q1b5XA49PTTT1c60wK4aHVxcQNcvt555x2TlJRk2rVrZ0JDQ42fn5+Jjo42Q4YMMc8++6zJzs6utM1bb71l+vbta5o0aWJCQ0PN1VdfbV544QVTWlpafsGXffv2Vdpux44dZsyYMSY8PNwEBASYjh07mscee8wUFRVVedGhrVu3mlmzZpn+/fub2NhY4+/vbyIjI03Pnj3N7373uyqvdLhv3z7zk5/8xLRq1coEBASY+Ph4M336dJOZmVl+8Zi5c+dW2MYTFx0qc+LECRMZGWkkmZdeeqnCfSkpKWbMmDEmNjbW+Pn5mSZNmphOnTqZCRMmmGXLlhmXy1XleGc7efKkefjhh03Hjh1NYGCgiYqKMqNGjTJbtmwx69atM5LMgAEDKm2XnZ1tpk2bZlq1amX8/PwqPf+Ffi6ffPKJGTt2rImOji6/oNOPf/zjShcbKnOui/qcb7xDhw6ZJ5980tx8882mdevWJjg42DRu3Nh07tzZ/OxnP6vygj7n+x083zwudNGhuXPnmtTUVDNx4kTTvHlz4+/vb9q1a2fmzJlT6d/qxIkT5tlnnzWjR4827du3N6GhoSYkJMR06NDBJCUlmS1btlQ5N+BiOYypR4cFA8Blbt68eZo/f77mzp2refPm1fV0AEkcMwAAgPWIAQAALEcMAABgOY4ZAADAcqwMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5XzregI1ZYyRq8CtkwVuud1G7lIjSfJxOuR0SqFBvmoU6COHw1HHMwUANETuUqN9WaeUetSlgpJSFRS75ZAU4OejYD8ftY0KVXzTYDmdDfd9psHFQFFJqY7kFOm4q1jHTxUrx1Usd+n5t3E6pCYhvgoP9VeTEF9Fhfkr0N/HOxMGADQoR04WaOOeLG3ff0JfZhzXNwdPqLDk/G80Qf4+6hYbpitbNlGX2DBd376ZmgT7e2nGNecwxpi6nsTFOH6qWKmZecrILpAxksMhVXfmZds4JLWICFCb5sGKaOTHqgEAWM4Yo8/2HdPSj9P1zteHVGokX6dDJaXVe6Mp28bPx6FburfQ5N4JurJlE89MuhbV6xgoLTXKyCrQ3sw85eaVyCGptiZb9lyhgT5qGx2s+Kgg+TTgJR4AQPUVFLu1YkuGFm9KU+pRl3ycjvLdzTVV9lydWzTWlL4JGtU9Vv6+9fNQvXobAzmuYm3Zk6uT+W6vjBcc4NTV7cIU0ajhLOsAAC7dlrRjun/5l9p/PF9S7X3YPFvZqnSH5qFaML67rmgR5qGRLl29i4HSUqNdB1zadcAlyXP/OGcrWyloFxOsTnGh8vVhlQAALkf5RW79Yc0uvfrRPjkcUi0tBFyQj8MhI6P7BrXXPQPb1atVgnoVA7muYm324mrAubBKAACXp8/Tj+sX/2+rDuTkey0CzuaQ1L55qBZO6KFOMY3rZhJnqTcxcDS3SB/vOq7SUu+tBpyL44f/uaZ9mFo0Dazj2QAAasO732TqZ298oVJj6iwEyvg4HfLzcWjxlGvUp21E3U5G9SQGMo8X6pPdOdU+O8AberZtrFaRQXU9DQBADazaul8PvPmVjKn7D5xlnA7J6XRo0eSe+lFi87qdS52OLulIbv0NAUn6fO8JHThWUNfTAABcopTthzTzza9UWo9CQDp9rILbbXTX0s+1aU9Wnc6lTmPg+Klifbyz/oZAmc27c3Ukt7CupwEAqKaNe7I043+31q8KOIORVGqMpi7ZrO37c+tsHnUWA+5So8++y633ISCd/sfa/F2uii5wBSoAQP2Rk1ekGf+7VaXG1NcWkHR6haDYXaqfLftCBcV1cwB9ncXAjoxTyit01+t/oDMVlxhtSztZ19MAAFykeat3KCevqEF86Cw1UsbxPP1xza46Gb9OYiD7ZJH2HMqri6EvmZGUkVWgQ8fZXQAA9d37Ow7rra0H6vysgeowRnrlw336PP2Y18f2egy4S4227MlVQ72kzxd72V0AAPVZTl6RHvz7NjXEr51xOKT7l3/l9d0FXo+BPYfylFdY2mB2D5ytuMSUXx0RAFD/PPefPcrNK24QuwfOVra7YPHGNK+O69UYMMYoNbNh7R44m5GUdiRfJe4G+FsGAJe5/CK3/nfz93I3xBL4gTHSa5vSau0Lky6GV2MgM6dIBcUNf4m9xG10IJtrDwBAfbP6q4NyFdbtJe1rQ+aJAq3fdcRr43k1BlIz8xrssQJn21vLKxwZWUf1p5R/6fPUPbX6vABgC2OMFm/cp8vh2+h9nA69tinNa+P5emugUwUlOpJb5K3hPC43r0THTxUrPNSvRs+TkXVUT7y1Qn9du0bF7hI1DgrW4VfeUIBfzZ4XAGzz1f5cfZt5eZwC7i41+vC7LKVnuxQfEeLx8by2MnAgu/CyWRWQTn+Z0f4a7CrIyDqqe155Qe1m3KmX1qSo2F0iSTqRn6djpy6PX2YA8Ka3vzoo38thWeAHDoeUsj3TK2N5bWUg51Sxx8fI3J+mVa8/r22bP9CxrMPy9fVTq7ad1G/QSA25ZZICAmvvC4eMTl9OubrOXgkAANSOLzNyVOLhg+5OfvFvHXvvRfnHdFBM0jMeHUuStu3P8fgYkhdj4Jir2KOnE27Z+J7+8Ju75Ofvr4E33aZWbRJVUlykb7d9pqXPPaqMfbt096w/1OqYOa5iGWPkuIiTWYkAAPCc0lKjrw96/tr+rh3r5RPWXEWHdqv4+EH5hbfw2FilRtqakeOx5z+TV3YTFBaXqqDIc2cRHD6YrmfmTFdkdJwWLtugO+5/TENumaSbxv5UMx99SQuXbVDL1h1rfVx3qXSq4PxHrZ5rdwDgSc8//7xat26toKAg9e7dW5s3bz7v45999lklJiYqODhYrVq10syZM1VY+N+rbc6fP19Op7PCn86dO3v6ZQAXLTXL5fGz1YpzMlV44Fs1/dEdcgaHyfXNeo+OJ0mZuQXKyfP88XZeWRnIdXl2F8Fbrz+vgjyXfvbwM2rarPJ3Qse0bK3h4+/0yNg5rmI1Cqr8Y2QlAHVl+fLleuCBB7Ro0SJdc801WrBggYYNG6bdu3erWbNmlR6/bNky/frXv9aSJUvUp08f7d69W8nJyXI6nfrDH/67mtalSxetXbtW5ofzt319vbawCFzQ1we8syrgDAxVUNteCu7YT64d69Wk/+0eH/frAyfUv33l/3Zrk1dWBnLzPftmuPmj99Q8Nl6J3Xp5dJyzORzSibyKr42VANS1BQsWaNq0aUpKSlJiYqJeeuklBQcH69VXX63y8R9//LH69++v8ePHq1WrVho8eLAmTpyozz77rMLjfH19FRkZqaioKEVFRalp06beeDnARdl1+KTHDx50fbNewR36yuHjp5BO16vk+EEVHtrt0TGdDmln5gmPjiF5aWWgxG3kcMgjl4bMc53UsaOHdM31N9b+k1+EsisR7j64X48sf12rPvtYJe6aXfDi64x0Hc7NqYXZ4XIUEhCg9jGxVd5XXFyszz//XA8//HD5bQ6HQ4MHD9bHH39c5TZ9+/bVG2+8oc2bN6tXr15KTU1VSkqKkpOTKzzuu+++U2xsrAIDA9WnTx898cQTatmyZZXPufvgAbkKuTAXvCftaLZHn78wc49Kju1X8JDpkqSAuCvk06iZXN+sV0BMB4+N63Q4vHIRJa/EgCcvqZjnOn0aXlBwqMfGOB93qdHWfXt19UO/UG19Y/awxx6plefB5alfx8768LdPVXlfVlaW3G63mjevuLusefPm2rWr6q9GnThxorKystS/f38ZY+R2uzV9+nQ99NBD5Y/p3bu3lixZoo4dO+rQoUOaN2+err/+en399dcKCal8DvQdLy7Uxl07avAqgepp2mygQhp1lMPhmQVv1zfr5AxposBWXSWdjuyQxOt0asc6hf/oDjmcPh4Z1+GQCkoukxjw5CWig0MaSZLy8055bpBzMadPMfwybW+thQDgbevXr9fvfvc7vfTSS7rmmmu0Z88e3XfffYqJidHs2bMlScOGDSt/fJcuXXTNNdcoPj5eb775pqZOnVpXUwf+y4NfUWhK3crb+aECW3VTSe7h8tv9W3RU6eZVKkj/SkGtr/LY+KVe+I4Cr8SAjwf34wSHNFLTZtH6fu9Oj41xTg7Jx+HQ1IFDtO7rbVr58UYVltT8YMlJ19+gkIDAWpggLkdtm8ec875mzZrJx8dHhw8frnD74cOHFR0dXeU2c+bMUVJSUvmb+hVXXKFTp05p2rRp5TFwtrCwMHXo0EF79lR9+exbevVWl1bxF/NygFrx9dEIHTjplCfeNwvSt8l96pjyvt2gvG83VLrftWO9x2LAGCnA1/OH93kvBjwYNj37DdF7//ybdm3foo5dr/bcQFVwOh1yOBz624xf6rk77taf31mtBW+/peOuS1+p+P1PpiomnIOzUH1+fn7q2bOn1q5dq5EjR0o6fb32tWvX6r777qtym7y8PDmdFf/Ppuzv57qOxqlTp7R3714lJSVV+Zy/HDmmJi8DqLZHV+/Q0k/SVOqBb5R17VgvZ3ATNf3heIEz5e3+WHm7P1bp0EI5/QJqfWwjKcDPM7sgzuSVswmCA5weXUQfPelnCgwK1gtPzFTOsaOV7s/cn6a3l79c6+MaI4UE/PcfKSw4RLNvnaDU5/+qR8dPUnhI3RzHALvNnDlTL7/8spYuXaqdO3dq+vTpysvL05QpUyRJSUlJFQ4wHDFihF588UUtX75caWlpeu+99zRnzhyNHDmyPAR+9atfacOGDUpPT9emTZs0evRo+fr6auLEiXXxEoFK4sKDPHJ8WmlxofJ2b1JQ214KSexf6U+jq4bLFOUrf8+ntT62dPq4tJZNgz3y3GfyyspAkxDPfulOdFyCfjH/RT0ze5rum3CdBtx0m1q1PX0Fwl3bt2jTf1brhpvHe2TsJqGVf4RlUTDjphG1slIAVMe4ceOUlZWlOXPm6PDhw+revbveffddRUZGSpL2799f4RoBjzzyiJxOpx555BEdOHBAkZGRGjlypB577LHyx+zfv1+33367srOzFRkZqf79++uTTz5RRESE118fUJWucWEeOT4tf8+nMkX5Cm5/bZX3B8R2PH0Boh3rFdLp+tqfgKSusWEeed4zOYzx5OF9pxljtHrzEbk9e3EoHcxI1T/feEFffXb6uwn8/PwV366z+g++RUNumSQ//9pfwhnRK0q+Puc/JiI3z1WtKDjwl6XsJgCAanAVlqjL3HdrfRX6yN8fVUHal4q7b5mcflUfy5X172fl2rFecfculU9Q41odP8jfR9/MGyanh6+h4JUYkKQN3xxT9knPf1mRN4UE+mho94u/KtTFRgExAADVN/DpdUrLzqvradSqaxLC9eb0vh4fx2tfYRwe6ufJMz+8ziGpaWj1dn9wTAEAeM5VrcI9evaat/k6HbqyZROvjOW1GIhs7O/R6w14m5EUFeZ/SdteKAoC/S7teQHAZn3bNfPoRe68raTUqG87z34nQRmvxUDzJv4K9PfacB7n6+NQbETNrgVwdhRc0bKVHhgxRuGhrBgAQHUN7xaj0IDL5wu0YsICdX37SK+M5bVjBiRp9wGXvslo+EfVOyS1jQlW1/hGdT0VAMAZHv/3Dr26Ma3BrxA4HdKDNyZq+oC23hnPK6P8ID4q6LI4bsBIat08qK6nAQA4y0+ujW/wISCd/oKicVdX/UVgHhnPayNJCvBzKrZpgBp6D0SF+Ss08PJZigKAy0VCsxD1b9dMFzjju17zcTo04soWahrivePHvL4Tv2Nsw98f3jG28re0AQDqh58Pbu+R7yjwprsHemf3QBmvx0DjYF8lxjXcN9O20cFq1pij/QGgvuqV0FTJfRPUUM8yvH9we3Vo7t1j0urk8P4OLULUONi3we0uCPJ3qnPLhr+yAQCXuwdv7KiYsKAGtbvAx+lQ55hGXjto8Ex1EgNOp0NXt6vdSzZ6w9Xtwi546WEAQN0L9vfVM+OulAe+xNCjFozvIV8f778119mJ/2HBfurUgD5ls3sAABqWa9tE6I7+rRvMKvQDQzuoY3TdnLJep1cB6tAiWPGRNbtwjzfEhAeoS3zDCRcAwGm/vilRQ69oXu+PH5h4TUvdXQe7B8rUaQw4HA71aNNYsRG1/22CtSUyzF+92ofJeTlcIAEALOPr49SfJvZQv3bN6mUQOCSN6Bajx0Z1laMO32e8egXCcyk1RltTT+j7owV1PZUKYsID1Kt92GX1xRcAYKPCErfuXbZV7+84XOtfc1wT466O0xNjutX5+0y9iAFJMsZoR8Yp7T5YP75+snVUkLq1bsSKAABcJkrcpZrzz2+07LPv5XSozq5F4HRIxkj33NBWvxzasU5XBMrUmxgok3WiSFv25Cq/qNTrYzsk+fs5dVWbxooOr7+7LgAAl27dziP61cqvdMxV5PUgcDqkFk2C9My47rqmdVPvDn4e9S4GJKnEfXqVYG+md1cJWkUGqmt8I/n7Xj7frggAqCw3v1i/fXuHVn6+3yurBGWrAVP7tdavhnVUkL+PZwespnoZA2WyThRpe/pJ5bhK5JBqfT9P2XM2CvJRl1aNWA0AAMus23VET6R8q92HT8nH6aj1Lzkqe85ucWGa/ePO9Wo14Ez1OgbK5LiKlZqZp4ysglqrN4dDim0aoDbRwWoa6lcv9tkAALzPGKMvvs/R3z5O09vbDsltjGryzlj2buLv69SYq2L1k2vj1SU2rFbm6ikNIgbKFJWU6vuj+Tp4rFA5rpLygnP8sPxSlTPv83GevthRdHiAEqKCFODH7gAAwH9lnyrUm1v26/1vD+ubg7kqKD59/Jqv06GSc3waPfO+YH8fdYsN09AronVrzziFBfl5be410aBi4EzGGLkK3co5VaIcV7FO5JfI7TZylxoZnV6a8fVxKDTQV+GhvmoS4qfQQB9WAAAAF6W01Cg1y6WvD+Rq+4FcpR49pbwit/KL3XJICvTzUUiAr9pHhapLbJi6xYWpVdPgBvk+02BjAAAA1A7WyQEAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABY7v8DGA6yLnRsuPkAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ss = ps.SubSpace([('B', 0)])\n", + "cmodel.show(probspace=ss, targetSpec=['C','A'], sensitivity=10, power=5, edgeLabels='rho', verbosity=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "ExecuteTime": { + "start_time": "2023-08-09T03:17:13.389060Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\tTesting A -> C direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 0.7832085723472961 \n", + "Backward:1.3033656709460217e-08\n", + "Rho-value: 0.7832085593136394\n", + "identifiable: True\n", + "triangles = []\n", + "Map = \n", + " A --> C ( 0.783 )\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ss = ps.SubSpace([('B', 1)])\n", + "cmodel.show(probspace=ss, targetSpec=['C','A'], sensitivity=10, power=5, edgeLabels='rho', verbosity=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Conditioning on B yields A->C" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "ExecuteTime": { + "start_time": "2023-08-09T03:17:13.399260Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\tTesting A -> B direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 0.0 \n", + "Backward:0.0\n", + "Rho-value: 0.0\n", + "identifiable: False\n", + "triangles = []\n", + "Map = \n", + " B --> A ( -0.0 )\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ss = ps.SubSpace([('C', 0)])\n", + "cmodel.show(probspace=ss, targetSpec=['B','A'], sensitivity=10, power=5, edgeLabels='rho', verbosity=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "ExecuteTime": { + "start_time": "2023-08-09T03:17:13.411734Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\tTesting A -> B direction\n", + "Using UCM test...\n", + "\n", + "\t**P-values** \n", + "Forward: 0.0 \n", + "Backward:1.107408427292178e-06\n", + "Rho-value: -1.107408427292178e-06\n", + "identifiable: False\n", + "triangles = []\n", + "Map = \n", + " B --> A ( 0.0 )\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGdCAYAAACPX3D5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAsaElEQVR4nO3deXjU1aH/8c9MZiYrCSGEAAkk7IGibC5sCi2bCygIslgIWK9VqdQKvdarFLDV1uqvUlu1FntFaWuvQqXWFiouoFYUUUGoCCprWAIkZCGTdWbO7w9MSkjClsxMwnm/nsc+Mts5E1LnPef7nTMOY4wRAACwljPcEwAAAOFFDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwygUb3++uu6+eab1b17d8XHxysyMlLt2rXTqFGjtHjxYh09ejTcUwy65557Tg6HQ7NmzTqn+zkcjlr/REdHKyMjQ1OnTtW//vWvRp1n1Rihcr4/l3DLyMiQw+HQnj17zul+s2bNksPh0HPPPReUeQGNiRhAo8jNzdWoUaM0evRoPffcc6qsrNQ3v/lNTZw4UT179tT69es1d+5cde7cWRs2bAj3dJu0MWPGaObMmZo5c6ZGjBihsrIyvfjii7ryyiv1+OOPh3t6ddqzZ48cDocyMjLCPRUA58EV7gmg+SssLNTQoUO1Y8cOZWZmasmSJbriiitq3Ka8vFzPP/+8Fi5cqEOHDoVpps3Dvffeq+HDh1f/uaSkRDNmzNDLL7+se+65R5MmTVJqamr4JnieJkyYoIEDByohISHcUwmJn//857r33nvVrl27cE8FOCNWBtBgc+bM0Y4dO5SRkaH33nuvVghIUmRkpL773e9q8+bN6tmzZxhm2XzFxMToN7/5jSSpoqJCr732WphndH4SEhKUmZlpzYtju3btlJmZaU38oHkjBtAgu3bt0gsvvCBJeuyxx9SqVavT3j4lJUU9evSo/vPx48f1zDPP6IYbblC3bt0UGxur2NhYXXTRRbr//vtVUFBQ5+Oc6Xj38OHD5XA4tG7duhqXFxYWav78+brooosUGxuryMhItW/fXkOGDNGCBQtUWVlZ4/ZvvPGG5syZo759+6p169aKjIxUWlqapkyZoo0bN572uTam9u3bKykpSZJ0+PDhOm+zYsUKXXXVVUpOTpbH41FqaqqmT5+ubdu2ndNY27Zt08KFCzVkyBClpqbK4/EoKSlJI0eO1EsvvVTr9rNmzVKnTp0kSXv37q113kOVM50z8OGHH2ry5Mlq3769PB6P2rRpo3Hjxun111+v8/YnH5PfvXu3ZsyYobZt2yoyMlJdunTR/PnzVV5eXut+gUBAS5Ys0ZAhQ9SyZUu53W61adNGffr00Zw5c057bsDatWs1evRoJSYmKjo6Wv3799eyZcvOOL+TLVq0SA6HQ4sWLdLevXuVlZWldu3aKSoqSt27d9eiRYtUWlpa52MuX75cI0eOVFJSktxut5KSktSrVy/deuut2rJlS73zBs7IAA3w+OOPG0mmZcuWxufznfP93333XSPJJCcnm6FDh5opU6aY0aNHm6SkJCPJdO3a1eTm5ta6nyRzul/fYcOGGUlm7dq11Zd5vV7Tu3fv6vHGjRtnpk6daoYPH27atm1rJJn8/Pwaj9OlSxfj8XhMv379zHXXXWduuOEG06tXLyPJuFwus2LFilpjL1261EgyM2fOPKefRdVzOnnOVfx+v4mMjDSSzP/+7//WuK6ystJMnjzZSDKRkZFm8ODB5sYbbzR9+vQxkkx0dLRZvXp1veOd6pZbbjGSTGZmphkzZoyZMmWKGTRokHE6nUaSufvuu2vc/plnnjETJ040kkxsbKyZOXNmjX/O5ueyZMmS6sfv16+fmTZtmhk8eHD1HBctWlTrPjNnzjSSzF133WXi4+NNenq6mTx5shk5cqSJjo42ksz48eNr3e/mm282kkxUVJQZOXKkmTZtmhkzZozp1q2bkWRWrlxZ4/bp6elGkvnxj39sHA6HGTBggJk6daoZOHBg9fwWL15c7/yWLl1a4/KFCxcaSSYrK8skJSWZlJQUc+ONN5qxY8ea2NhYI8kMGTLElJaW1rjfAw88UP17d+WVV5pp06aZa665xvTu3ds4HI465wCcLWIADTJjxgwjyXzrW986r/tnZ2ebN954w/j9/hqXe71ek5WVZSSZ2bNn17rf+cTA888/bySZq6++2lRUVNS4vd/vN+vWrTPl5eU1Ll+5cqU5duxYrcdfuXKlcblcJikpyZSUlNS4LhgxsGbNGiPJeDwec+DAgRrX3XfffUaSufzyy82uXbtqXLd8+XITERFhEhMTa4VOfT/DdevWmZ07d9a6fPv27SYtLc1IMhs2bKhx3e7du40kk56eXu/zq+/nsmXLFuNyuYzD4TDLli2rcd2qVauMx+MxksyaNWtqXFf1YivJ3H///TVidOvWrdUvrOvXr6++fO/evUaSSUtLM4cOHao1x23btpm9e/fWuKwqBtxut3n11VfrfE4JCQm1fg/OFAOSzPXXX1/jftnZ2aZ79+5Gkrn33nurLy8rKzPR0dEmLi7ObN++vda89+zZYz7//PNalwNni8MEaJCqjwq2adPmvO6flpamESNGyOms+asYExOj3/72t3K5XFq+fHmD5yn9Z3l91KhRcrvdNa5zOp0aNmyYPB5PjcvHjx+vxMTEWo81fvx43XjjjcrLy9PatWsbZX51yc3N1YoVKzRr1iw5nU498cQTat++ffX1x44d0+LFixUVFaW//OUv1cv1VSZNmqTbbrtN+fn5+uMf/3hWYw4bNkydO3eudXmPHj304x//WNKJQxKN5fHHH5fP59OECRM0Y8aMGtddffXV+u53vytJevTRR+u8/4ABA/TTn/5UERER1Zf17t27+rHeeOON6surfgf69++vtm3b1nqsnj17qmPHjnWOM2fOHI0dO7bGZbNmzVJmZqYKCwv10Ucfnemp1hAdHa2nn35a0dHR1ZelpaXpl7/8pSTpqaeeUllZmSSpqKhIpaWl6ty5c43DbFXS09OVmZl5TuMDJ+PTBGgS1q9fr3fffVf79u1TSUmJjDGSJI/Ho6NHjyo/P7/OF+Vzcemll0qSHnnkESUlJWns2LFnPMdBkg4ePKh//OMf2r59uwoLC+Xz+SRJn332mSRpx44duuaaaxo0t5N985vfrHVZdHS01qxZoxEjRtS4fO3atSotLdWIESPq/YTB8OHD9dRTT2n9+vW68847z2oOxcXFWr16tTZt2qTc3FxVVFRIUvUnQXbs2HEuT+m0qs7rqO9cgltuuUVPPPGE3n33Xfn9/hov+pI0duzYOs8fqTpR9cCBA9WXZWZmqkWLFlq1apUeeugh3XTTTbUCqj7jxo2r8/KePXtq+/btNcY5G6NHj64zSMaOHaukpCTl5eXpk08+0eDBg5WcnKyMjAxt2bJF8+bN0y233KJevXqd03jA6RADaJDk5GRJ0pEjR87r/keOHNHEiRPPuKFOUVFRg2Ng+PDh+tGPfqRHH31UM2fOlMPhULdu3TRkyBBdf/31GjduXK0VigceeEAPPfRQrRMLT51bYxozZozatm2rQCCgnJwcvfPOOyotLdX06dP13nvv1XjXvmvXLknSm2++ecYNhM52w6dXX31VN998s/Ly8uq9TWM+56oX0fpelLt06SJJKisrU15eXq1VqPreycfHx1ffr0qLFi20dOlS3XzzzZo/f77mz5+vdu3aaeDAgbrqqqt00003KS4urs7HO5dxzsbpIiQjI0N5eXnav39/9WXLli3TpEmT9Nhjj1WfrHv55Zdr1KhRmjFjhlq3bn1O4wMn4zABGmTAgAGSpE8++UR+v/+c7/9f//Vf+te//qVBgwZpzZo1Onz4sCoqKmROnM9S/TG0qpWCsxUIBOq8/OGHH9bOnTv161//WjfeeKO8Xq+WLl2q8ePHa+DAgfJ6vdW3ffnll7Vo0SJFRkbqd7/7nb788kt5vV4FAgEZY/Q///M/5zW3M7n33nv13HPPadmyZVqzZo127dql3r17KycnRzfddFON8aqeZ9euXas3Kqrvn1NXFepy4MABTZkyRXl5ebrnnnv06aefqrCwUH6/X8aY6o81NvZzbohTA+5MJk6cqOzsbC1btky33nqrEhMTtXLlSt12223q2rWrtm7d2ijjNIaTf85XXHGF9uzZo+XLl+vOO+9URkaGXnvtterNvN58882Qzw8XDlYG0CBjx47V3LlzVVBQoL/97W+aMGHCWd/X6/Vq1apVcjqdWrVqlVq2bFnr+pycnDrv63a7VVlZqePHj6tFixa1rt+7d2+942ZkZGjOnDmaM2eOJGnjxo2aPn26Nm7cqEceeUQPPPCAJFV/jO6hhx6qPm59si+//PKsnmdDtW/fXsuXL9fFF1+sDRs26E9/+pOmT58uSerQoYOkE8fzG2Pb21dffVWlpaWaMGGCfvGLX9S6PhjPOTU1VTt37qyOnlNVrX5ERUWd1WGds5GQkKAZM2ZUn1eQnZ2tOXPm6JVXXtGdd96pt99+u1HGOZ3du3fXe13VxxvT0tJqXB4dHa1JkyZp0qRJkk6s9syfP19LlizRd77zndP+3gOnw8oAGqRLly6aNm2aJGnevHk6duzYaW9/5MiR6uPNVe844+Pja4WAJP3xj3+s9x1o1fHxzz//vNZ1W7ZsUXZ29lk/h0svvVSzZ8+WJG3evLn68qrnkp6eXufzqO/z78GQmZmpO+64Q9KJz6lXnbcwYsQIeTwerVu37rwP1ZzsdM/ZGFO9p8Spqk68rJrXuajabbG+mHn22WclnXhn7HIF5/1Lhw4dqiPw5N+BYFqzZk2df2erVq1SXl6eWrRoUb3yVp/k5GQ98sgjkqR9+/YpPz8/KHPFhY8YQIP95je/UdeuXbV7924NHTq0zuP/FRUVevbZZ9WvX7/qF/CUlBQlJiaqoKBAf/jDH2rc/oMPPqhehq/LyJEjJZ04pn/yxjJ79uzRzJkz64yIlStX6p133ql1CKGyslL//Oc/JdV8Eaw6AW3JkiXVJ9BJJyJm5syZKiwsrHd+wTB//nzFxcVp586dev755yWd+BnOmTNHXq9X48aNq3OJu7y8XH/729+0ffv2M45R9ZxXrFhRY9tov9+vBQsWaP369XXer2qjo5ycnDMG4anuuusuuVwu/fWvf631iYc1a9bod7/7nSTphz/84Tk9bl02bdqkF198sc5NfV599VVJdYdQMJSWluqOO+6oMZeDBw9q3rx5kqTbb79dUVFRkk6sdP3+97+v81yNqnknJiZWn78AnCsOE6DBEhMT9d5772nKlClat26drrjiCnXq1EkXX3yxYmJidPjwYX344YcqLi5WfHx89UfjIiIitGDBAt19993KysrSk08+qc6dO2vfvn1av369pk+frnfeeafOpc/77rtPK1as0KpVq9S9e3ddeumlOnr0qDZu3KghQ4Zo8ODBtV643n77bT3++ONq3bq1+vXrpzZt2uj48eP64IMPdOTIEaWmpuqee+6pvv0PfvADLVu2TKtWrVLnzp01cOBAVVZW6u2331ZMTIy+853vVL9rDYXk5GTNnTtXP/nJT/Tggw8qKytLbrdbDz/8sA4dOqQXXnhBffv2VZ8+fdS5c2e5XC7t379fmzdvltfr1erVq8/48bNx48ZpwIAB+vjjj9W9e3cNGzZMsbGx2rBhgw4ePKgf/ehHdR4+cLvduu6667RixQr17dtXQ4cOVUxMjCTp97///WnHvOiii/Tkk0/qjjvu0IwZM7R48WJlZmZq7969Wr9+vYwxWrRokUaPHn3+P7yv7d27V1OnTq3ePbBDhw7y+XzaunWrduzYIY/HU/1OO9iysrL097//XZ07d9YVV1yhsrIyvfXWW/J6vRo0aFD1SoUk5efn69Zbb9Xs2bPVt2/f6pMPv/zyS23atEkOh0OPPvporU9aAGctHJsb4MK1evVqk5WVZbp27Wri4uKM2+02bdu2NaNGjTK/+tWvTF5eXq37/PWvfzWDBw82LVu2NHFxceaSSy4xTz31lAkEAtUbvuzevbvW/bZt22ZuuOEGk5iYaCIjI02PHj3Mgw8+aCoqKurcdGjTpk3m3nvvNUOHDjWpqanG4/GY5ORkM2DAAPOzn/2szp0Od+/ebb797W+bjh07msjISJOenm5uv/12k5OTU715zMKFC2vcJxibDlUpKioyycnJRpJ5+umna1y3atUqc8MNN5jU1FTjdrtNy5YtTc+ePc3UqVPNCy+8YLxeb53jner48ePmvvvuMz169DBRUVGmTZs2Zvz48eajjz4ya9euNZLMsGHDat0vLy/P3HbbbaZjx47G7XbXevwz/Vw++OADM2nSJNO2bdvqDZ2uvfbaWpsNValvU5/TjXfo0CHz8MMPm2uuucZ06tTJxMTEmPj4eNOrVy/zve99r84NfU73O3i6eZxp06GFCxeaXbt2mWnTppmUlBTj8XhM165dzYIFC2r9XRUVFZlf/epXZsKECaZbt24mLi7OxMbGmu7du5usrCzz0Ucf1Tk34Gw5jGlCpwUDwAVu0aJFeuCBB7Rw4UItWrQo3NMBJHHOAAAA1iMGAACwHDEAAIDlOGcAAADLsTIAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWc4V7Ag1ljJG3zK/jZX75/Ub+gJEkRTgdcjqluGiXWkRFyOFwhHmmAIDmyB8w2p1brF1HvSrzBVRW6ZdDUqQ7QjHuCHVpE6f0VjFyOpvv60yzi4EKX0BHCiqU761UfnGlCryV8gdOfx+nQ2oZ61JinEctY11qk+BRlCciNBMGADQrR46X6b2vcrV1f5E2Z+frs4NFKved/oUm2hOhi1MT1KdDS/VOTdCV3VqrZYwnRDNuOIcxxoR7Emcjv7hSu3JKlJ1XJmMkh0M615lX3cchqX1SpDqnxCiphZtVAwCwnDFGH+4+pmXv79Xqfx9SwEgup0O+wLm90FTdxx3h0PV922vGwAz16dAyOJNuRE06BgIBo+zcMu3MKVFhiU8OSY012arHiouKUJe2MUpvE62IZrzEAwA4d2WVfi3/KFtL1+/RrqNeRTgd1YebG6rqsXq1j9eswRka3zdVHlfTPFWvycZAgbdSH31VqOOl/pCMFxPp1CVdE5TUovks6wAAzt9He47p7hc3a39+qaTGe7N5qqpV6e4pcVo8pa++0T4hSCOdvyYXA4GA0Y4DXu044JUUvL+cU1WtFHRtF6OeaXFyRbBKAAAXotIKv/7fmh169l+75XBIjbQQcEYRDoeMjL4/optmD+/apFYJmlQMFHortTGEqwH1YZUAAC5MH+/N1w/+b5MOFJSGLAJO5ZDULSVOj0/tp57t4sMziVM0mRg4Wlih93fkKxAI3WpAfRxf/89l3RLUvlVUmGcDAGgMr32Wo+/96RMFjAlbCFSJcDrkjnBo6azLNKhLUngnoyYSAzn55frgi4Jz/nRAKAzoEq+OydHhngYAoAFWbtqveS99KmPC/4azitMhOZ0OLZkxQN/KTAnvXMI6uqQjhU03BCTp451FOnCsLNzTAACcp9VbD2nuS58q0IRCQDpxroLfb/TdZR9r/Ve5YZ1LWGMgv7hS729vuiFQZeMXhTpSWB7uaQAAztF7X+Xqzj9valoVcBIjKWCMbn5uo7buLwzbPMIWA/6A0YdfFjb5EJBO/GVt/LJQFWfYgQoA0HQUlFRozp83KWBMU20BSSdWCCr9AX3vhU9UVhmeE+jDFgPbsotVUu5v0n9BJ6v0GW3Zczzc0wAAnKVFr25TQUlFs3jTGTBSdn6JfrlmR1jGD0sM5B2v0FeHSsIx9HkzkrJzy3Qon8MFANDUvbHtsP666UDYPzVwLoyRfv/ubn2891jIxw55DPgDRh99VaTmuqXPJzs5XAAATVlBSYXu+csWNcevnXE4pLtf/DTkhwtCHgNfHSppVocHTlXpM9W7IwIAmp4n3vpKhSWVzeLwwKmqDhcsfW9PSMcNaQwYY7Qrp3kdHjiVkbTnSKl8/mb4WwYAF7jSCr/+vHGf/M2xBL5mjPT8+j2N9oVJZyOkMZBTUKGyyua/xO7zGx3IY+8BAGhqXv30oLzl4d3SvjHkFJVp3Y4jIRsvpDGwK6ek2Z4rcKqdjbzCUVZWpv379+v4cT6xAODCV1xZoUMlxSr3N94LtzFGS9/brQvh2+gjnA49v35PyMZzhWqg4jKfjhRWhGq4oCss8Sm/uFKJce4GPU5ZWZn27dunQ4cOKRAIyOVyaciQIXI6w745JAAERcAYfV6YJ78x2uctUpuoGLWPaaHIiIgGPe6n+wv1ec6F8YbKHzB698tc7c3zKj0pNujjhewV50Be+QWzKiCd+DKj/Q04VFBWVqYvvvhCGzZsUHZ2to4dO6ajR4/K7/ersrKy8SYKAE2MLxCoPqZvJB0uK9HmY4e1+3hBg1YK/v7pQbkuhGWBrzkc0qqtOSEZK2QrAwXFwXuBe+sf/6cnHvxBjcviE5PUsVMPjZ/+PfUfNKLRxzQ6sZ3yuTp5JcDn86moqEhFRUUyxig6mi9EAmCnqig4UlZy3isFm7ML5AvySXfHP/mHjr3+W3nadVe7rMeCOpYkbdlfEPQxpBDGwDFvZdA/Tjj11nuU0r6jjDEqOHZUa1e9qAfnflv3PbpMlwwd3ejjFXgrZYyR4yw+zFpfBEhSfHy8ysvZzAgAzjcKAgGjfx8M/t7+3m3rFJGQoopDX6gy/6Dcie2DNlbASJuyC4L2+CcLyWGC8sqAyiqC/ymC/oO+pWFXTdLwq2/U+G/P1kO/fUUul1vvvv7XoIznD0jFZadf0qrrcMD+/ftVVFSk+Ph4paWlKTExkXMEEFRPPvmkOnXqpOjoaA0cOFAbN2487e2XL1+unj17Kjo6Wn369NHq1atDNFPghHM9fLAr1xv0T6tVFuSo/MDnavWtW+SMSZD3s3VBHU+ScgrLVFAS/PPtQvIKVOgNzzHw2BYJ8kRGKaKBJ6WcTkE9z+1sIyCYcwMk6cUXX9S8efP0wAMPaNOmTerTp4/GjBmj3Ny6vzJ1/fr1uummm3Trrbdq8+bNuv766zV+/Hht27YtxDMHzj4K/n0gNKsCzqg4RXe5VDE9hsi7bV3Qx5Skfx8oCvoYoYmBUl8ohlFJ8XEVFeSpMD9X+3Zt1+8e+ZHKSr268qpJQRnP4ZCKSmo+NyIATc3ixYt12223KSsrS5mZmXr66acVExOjZ599ts7b//rXv9bVV1+tuXPnqkePHvrJT36i/v3764knngjxzIH/OFMU7Dh8POgnD3o/W6eY7oPliHArtueV8uUfVPmhL4I6ptMhbc8JfgyE5JwBn9/I4VDQt4Zc9P0ba/zZ7YnU9+5brL6XDQvamKU+v7y+SpWWlmp/drbyjh2T3+eTt6REJSUn9iJIaJOsmOhoOSMiZCTVlUbOqCgZGfkinMorPi53OZsa4ewlxsbJVUdgVlZW6uOPP9Z9991XfZnD4dDIkSP1/vvv1/lY77//vubNm1fjsjFjxuiVV16p8/Y+v1/53uIGzB628ZnzX86vioLDZSWKd7qU4o5UpDNCBcWljTfBOpTnfCXfsf2KGXW7JCky7RuKaNFa3s/WKbJd96CN63Q4QrKJUkhiIFRbKt76w5+rfYcukqSC/KN6558r9NTP5yk6Nk4Dh1/b6OMZY5RbWqqt+V9vQJScqNjkRElS/Dk+VtxJ/74vUCGVXzh7MiD4LoqJkUu1YyA3N1d+v18pKSk1Lk9JSdGOHXV/VWpOTk6dt8/JqfsjTuUmoJ3lfF8HQq8o4FNhWaXKd+7V/kPHFQjiO07vZ2vljG2pqI4XSToR1bGZV6h421olfusWOZzBWe11OKQy3wUSA6HaIrpbr37q2rNv9Z+vGDVB82aO1DO/vE8DhoyS2+0JzUQAACHhcDjkjIpUwARvsyET8Ktk+7uK6nixfIWHqy/3tO+hwMaVKtv7qaI79Q/a+IEQvKEOSQxEhGkTCKfTqd79h+gfLz2jQ9m71LFzZqM+vkMOxbgi1CbKrby8PB0vKlLAGPl8Pvl8Phlj5IqIkMvlluMMP4OKihMrAR6PR4ktE+WM4NMFOHvOev5j0bp1a0VEROjw4cM1Lj98+LDatm1b533atm17Trd3Bowiy9koC2fPSKqIbNjurSceyMhT4VNibAu1bFEiR06RgvEZ9rK9W+QvPqaSz99Ryefv1Lreu21d0GLAGCnSFfzXg9DFQJi+QCrgP3GEvqw0CN+W6JBaRkapc4sW6tyipXw+nw4cOKDs7GxVVFSouLhYuYWF8vv9iouLU0JCgtzuuv8PcOzIERljlJKSot6Z31BkZGTjzxfWcbvdGjBggN58801dd911kk4c3nrzzTf1/e9/v877DBo0qNb1r7/+ugYNGlTn7aM9HvVLS2/8yeOCVeH365Njh898w3pEOBxqHx2nlOhYub7+WHbKDp8cXx1XMF5svNvWyRnTUq2+Pl/gZCVfvK+SL95XYHS5nO7G/++2kRTpDv4J5yGJgZhIZ1hawOer1OYP35bL7VFaRrdGf3xjpJjI//wluVwupaenKzU1tToK4uLiVFxcrMLCQhUXF58xCoDGNnfuXM2aNUsDBgzQZZddpsWLF6ukpESzZs2SJGVlZSktLU0/+9nPJEl33XWXhg8frscee0zXXnut/vznP+vjjz/WM888E8ZnAdQdAVXSEqODcn5aoLJcJV+sV0yPoYrNHFp7TnFJKvn8bZV+tUGxPa9s9PH9AaMOrWIa/XFPFZIYaBkbmhe+T95/Swf2fiVJKszP1btrXtah7F26YcYcxcS2CMqYiXG1f4REAZqSyZMnKzc3VwsWLNDhw4fVt29fvfbaa0pOTpYk7d+/Xy7Xf36PBw0apBdeeEH333+/7r//fnXr1k2vvPKKevXqFa6nAMudLgKqXJSWEJTz00q/2iBTUaqYbpfXeX1kao8TGxBtWxeUGJCki1ITgvK4JwtJDMRFRSjCeWLHvmD6v2ceqf53jydKqeldddt//0KjJ2QFbcyEmPpfzM8lCoBgmj17tmbPnl3ndW+99VatyyZOnKiJEycGe1rAaZ1NBFTp1S5eDjX+QQLvtnVyuDyKyuhb5/UOh1PRnS+Vd9s6+UuLFBF9rp8lO71oT4TSQ7Ay4DAmNOf6v/PZMeUdv7BOMoqNitDovq3P+vZ1nVNQ+PU5BU6nU5GRkUpJSdGgQYM4ZwDABetM5wycSwScbPija7UnLwjnh4XRZRmJeun2wUEfJ2RfVJQY59ax4sqQfcww2BySWsWd2xL/mVYKAMBm5xsBVfp3TFR2fmnI9rYJNpfToT4dWoZmrJCMIik53qOvDl04xWYktUk4v30L6ouCqm8u5EuLAFzInKd802tDI6DK4K6t9fKmAw2dXpPhCxgN7nr2q88NEbJXnZSWHkV5LpwXOVeEQ6lJUQ17jK+jYODAgerSpYtat26tDh06cFIhgAuay+lUu+hYRUe41CGmhfq1SlFqbIsGhYAkjb24neIiQ/YeN+jaJUTpym7JIRkrZD81h8Ohzikx2pbd/Pcwd0jKaBPdaJspVUVBejqf1QZgh/S4BDX2f/Gi3BGadlkHPfvenmZ/qMDpkGYOzgjZpn0hfaue0SZajvBsRtiojKROKdHhngYA4BTfvjy92YeAdOJQyuRLOoRuvJCNJCnS7VRqq0g19x5ITvAoLurCWYoCgAtFRutYDe3aWhHN+IUmwunQuD7t1So2dN+nE/KD+D1S4858oyYuMzU23FMAANTjrpHd1NwXB+4Y3iWk44U8BuJjXMpMa74vpl3axqh1PN9+CABN1aUZrTRzcIbC9B15DXb3yG7qnhKcXXPrE5bT+7u3j1V8jKvZHS6I9jjVq0PzX9kAgAvdPVf1ULuE6GZ1uCDC6VCvdi10+7DQrgpIYYoBp9OhS7o27paNoXBJ1wS5mtNvFgBYKsbj0mOT+8jfzA4XLJ7ST64wfIV92D74nxDjVs9m9C6bwwMA0Lxc3jlJtwzt1GxWoeeN7q4ebUN7eKBKWHcB6t4+RunJDdu4JxTaJUaqd3rzCRcAwAn/c3WmRn0jpcmfPzDtsg66IwyHB6qENQYcDof6dY5XalLT/VKe5ASPLu2WUGv7TABA0+eKcOo30/ppcJfWTTIIHDqxc+KD4y+SI4yvMyH71sLTCRijTbuKtO9oWbinUkO7xEhd2i0hZDtAAQCCo9zn150vbNIb2w43+tccN8TkS9L08xsuDvvrTJOIAUkyxmhbdrG+ONg0vsyoU5toXdypBSsCAHCB8PkDWvDKZ3rhw31yOhS2vQicDskYafY3u+iHo3uEdUWgSpOJgSq5RRX66KtClVYEQj62Q5LH7VT/zvFqm9h0D10AAM7f2u1H9N8rPtUxb0XIg8DpkNq3jNZjk/vqsk6tQjv4aTS5GJAkn//EKsHOnNCuEnRMjtJF6S3kcV04364IAKitsLRSP/37Nq34eH9IVgmqVgNuHtJJ/z2mh6I9EcEd8Bw1yRiokltUoa17j6vA65NDavTjPFWP2SI6Qr07tmA1AAAss3bHEf181ef64nCxIpyORv+So6rHvDgtQfOv7dWkVgNO1qRjoEqBt1K7ckqUnVvWaPXmcEiprSLVuW2MWsW5m8QxGwBA6Blj9Mm+Av3h/T36+5ZD8hujhrwyVr2aeFxO3dA/Vd++PF29UxMaZa7B0ixioEqFL6B9R0t18Fi5Cry+6oJzfL38UpeTr4twntjsqG1ipDLaRCvSzeEAAMB/5BWX66WP9uuNzw/rs4OFKqs8cf6ay+mQr553oydfF+OJ0MWpCRr9jbaaOCBNCdHukM29IZpVDJzMGCNvuV8FxT4VeCtVVOqT32/kDxgZnViacUU4FBflUmKcSy1j3YqLimAFAABwVgIBo125Xv37QKG2HijUrqPFKqnwq7TSL4ekKHeEYiNd6tYmTr1TE3RxWoI6topplq8zzTYGAABA42CdHAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDliAEAACxHDAAAYDliAAAAyxEDAABYjhgAAMByxAAAAJYjBgAAsBwxAACA5YgBAAAsRwwAAGA5YgAAAMsRAwAAWI4YAADAcsQAAACWIwYAALAcMQAAgOWIAQAALEcMAABgOWIAAADLEQMAAFiOGAAAwHLEAAAAliMGAACwHDEAAIDl/j+qnUkZXaq7ZwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ss = ps.SubSpace([('C', 2)])\n", + "cmodel.show(probspace=ss, targetSpec=['B','A'], sensitivity=10, power=5, edgeLabels='rho', verbosity=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Seems like conditioning on C blocks flow of information from B->A (this is what we would expect), so the direction is not identifiable." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "start_time": "2023-08-09T03:17:13.418303Z" + } + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.6" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/because/probability/ucm/models/M1A.py b/because/probability/ucm/models/M1A.py new file mode 100644 index 0000000..429b234 --- /dev/null +++ b/because/probability/ucm/models/M1A.py @@ -0,0 +1,41 @@ +# ---------------------------------------------------------------------------- +# Model Definition +# ---------------------------------------------------------------------------- +from probability.ucm.ucm import UCVar +from random import seed +seed(1) + +# Initialize any variables here +# For models variables, initialize the variables outside the model equations +varA = UCVar([0.9, 0.1]) +varC = UCVar([0.2, 0.4, 0.4]) +varB = UCVar([0.2, 0.1, 0.1, 0.1, 0.5], parent=[varA, varC]) + +# print("\nA Distribution: \t") +# pprint.pprint(varA.distribution) +# print("\nC Distribution: \t") +# pprint.pprint(varC.distribution) +# print("\nB Distribution: \t") +# pprint.pprint(varB.distribution) + + +# Describe the test +testDescript = 'Reference Model M1A Categorical -- simple V structure' + +# Define the causal model. +# Each random variable has the following fields: +# - Name +# - List of Parents +# - isObserved (Optional, default True) +# - Data Type (Optional, default 'Numeric') +model = [('A', []), + ('C', []), + ('B', ['A', 'C']) + ] + +# Structural Equation Model for data generation +varEquations = [ + 'A = varA.get_value()', + 'C = varC.get_value()', + 'B = varB.get_value([A,C])' +] \ No newline at end of file diff --git a/because/probability/ucm/models/M1Aold.py b/because/probability/ucm/models/M1Aold.py new file mode 100644 index 0000000..6b4903b --- /dev/null +++ b/because/probability/ucm/models/M1Aold.py @@ -0,0 +1,44 @@ +# ---------------------------------------------------------------------------- +# Model Definition +# ---------------------------------------------------------------------------- +import numpy +from random import seed +seed(1) +# Initialize any variables here +aDist = [0.25, 0.75] +cDist = [0.3, 0.7] + +bBaseDist = [] +bDist = { + 0: [1 / 3, 1 / 3, 1 / 3], + 1: [0.25, 0.25, 0.5] +} + +## Alternative variable distribution +# aDist = [0.25, 0.75] +# cDist = [0.1, 0.9] +# bDist = { +# 0: [0.8, 0.1, 0.1], +# 1: [0.1, 0.1, 0.8] +# } + + +# Describe the test +testDescript = 'Reference Model M1A Categorical -- Simple V' + +# Define the causal model. +# Each random variable has the following fields: +# - Name +# - List of Parents +# - isObserved (Optional, default True) +# - Data Type (Optional, default 'Numeric') +model = [('A', []), + ('C', []), + ('B', ['A', 'C']) + ] + +varEquations = [ + 'A = choice(range(0,2), p=aDist)', + 'C = choice(range(0,2), p=cDist)', + 'B = choice(range(0,3), p=bDist[(A + C) % 2])' +] diff --git a/because/probability/ucm/models/M1B.py b/because/probability/ucm/models/M1B.py new file mode 100644 index 0000000..23db87d --- /dev/null +++ b/because/probability/ucm/models/M1B.py @@ -0,0 +1,45 @@ +# ---------------------------------------------------------------------------- +# Model Definition +# ---------------------------------------------------------------------------- + +# Initialize any variables here +bDist = [0.3, 0.7] +aDist = { + 0: [0.2, 0.8], + 1: [0.8, 0.2] +} + +# Non UC distribution +cDist = { + 0: [0.1, 0.9], + 1: [0.4, 0.6] +} +## Uniform channel distribution +# cDist = { +# 0: [0.1, 0.9], +# 1: [0.9, 0.1] +# } + + +# Describe the test +testDescript = 'Reference Model M1B Categorical -- Simple Inverted V' + +# Define the causal model. +# Each random variable has the following fields: +# - Name +# - List of Parents +# - isObserved (Optional, default True) +# - Data Type (Optional, default 'Numeric') +model = [('B', []), + ('A', ['B']), + ('C', ['B']), + ] + +varEquations = [ + 'B = choice(range(0,2), p=bDist)', + 'A = choice(range(0,2), p=aDist[B])', + 'C = choice(range(0,2), p=cDist[B])', +] + + + diff --git a/because/probability/ucm/models/M1C.py b/because/probability/ucm/models/M1C.py new file mode 100644 index 0000000..e75d7d2 --- /dev/null +++ b/because/probability/ucm/models/M1C.py @@ -0,0 +1,35 @@ +# ---------------------------------------------------------------------------- +# Model Definition +# ---------------------------------------------------------------------------- + +# Initialize any variables here +bDist = { + 0: [0.6, 0.2, 0.2], + 1: [0.2, 0.2, 0.6] +} + +cDist = { + 0: [0.1, 0.1, 0.1, 0.7], + 1: [0.1, 0.7, 0.1, 0.1], + 2: [0.1, 0.1, 0.7, 0.1] +} + +# Describe the test +testDescript = 'Reference Model M1C Categorical-- 3 variable chain (growing cardinality) ' + +# Define the causal model. +# Each random variable has the following fields: +# - Name +# - List of Parents +# - isObserved (Optional, default True) +# - Data Type (Optional, default 'Numeric') +model = [('A', []), + ('B', ['A']), + ('C', ['B']), + ] + +varEquations = [ + 'A = choice(range(0,2), p=[0.3, 0.7])', + 'B = choice(range(0,3), p=bDist[A])', + 'C = choice(range(0,4), p=cDist[B])', +] diff --git a/because/probability/ucm/models/M1Cv2.py b/because/probability/ucm/models/M1Cv2.py new file mode 100644 index 0000000..e643525 --- /dev/null +++ b/because/probability/ucm/models/M1Cv2.py @@ -0,0 +1,37 @@ +# ---------------------------------------------------------------------------- +# Model Definition +# ---------------------------------------------------------------------------- + +# Initialize any variables here +bDist = { + 0: [0.6, 0.2, 0.2], + 1: [0.2, 0.2, 0.6], + 2: [0.2, 0.6, 0.2], + 3: [0.6, 0.2, 0.2] +} + +cDist = { + 0: [0.3, 0.7], + 1: [0.7, 0.3], + 2: [0.3, 0.7] +} + +# Describe the test +testDescript = 'Reference Model M1C Categorical-- 3 variable chain (shrinking cardinality)' + +# Define the causal model. +# Each random variable has the following fields: +# - Name +# - List of Parents +# - isObserved (Optional, default True) +# - Data Type (Optional, default 'Numeric') +model = [('A', []), + ('B', ['A']), + ('C', ['B']), + ] + +varEquations = [ + 'A = choice(range(0,4), p=[0.1, 0.1, 0.2, 0.6])', + 'B = choice(range(0,3), p=bDist[A])', + 'C = choice(range(0,2), p=cDist[B])', +] diff --git a/because/probability/ucm/models/M2.py b/because/probability/ucm/models/M2.py new file mode 100644 index 0000000..43b2fcf --- /dev/null +++ b/because/probability/ucm/models/M2.py @@ -0,0 +1,41 @@ +# ---------------------------------------------------------------------------- +# Model Definition +# ---------------------------------------------------------------------------- + +# Initialize any variables here +from probability.ucm.ucm import UCVar +# For models variables, initialize the variables outside the model equations +varB = UCVar([0.9, 0.1]) +varA = UCVar([0.25, 0.25, 0.5], parent=varB) +varC = UCVar([0.2, 0.1, 0.1, 0.1, 0.5], parent=[varA, varB]) + +## Alternative distribution +# varB = UCVar([0.4, 0.5, 0.1]) +# varA = UCVar([0.25, 0.25, 0.5], parent=varB) +# varC = UCVar([0.3, 0.7], parent=[varA, varB]) + +## Alternative distribution +# varB = UCVar([0.2, 0.1, 0.1, 0.1, 0.5]) +# varA = UCVar([0.25, 0.25, 0.1, 0.4], parent=varB) +# varC = UCVar([0.2, 0.8], parent=[varA, varB]) + +# Describe the test +testDescript = 'Reference Model M2' + +# Define the causal model. +# Each random variable has the following fields: +# - Name +# - List of Parents +# - isObserved (Optional, default True) +# - Data Type (Optional, default 'Numeric') +model = [('B', []), + ('A', ['B']), + ('C', ['B', 'A']), + ] + +# Structural Equation Model for data generation +varEquations = [ + 'B = varB.get_value()', + 'A = varA.get_value(B)', + 'C = varC.get_value([A,B])' +] \ No newline at end of file diff --git a/because/probability/ucm/models/__init__.py b/because/probability/ucm/models/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/because/probability/ucm/models/categTest1.py b/because/probability/ucm/models/categTest1.py new file mode 100644 index 0000000..ea28a7f --- /dev/null +++ b/because/probability/ucm/models/categTest1.py @@ -0,0 +1,33 @@ +# ---------------------------------------------------------------------------- +# Model Definition +# ---------------------------------------------------------------------------- + +# Initialize any variables here +t = 0 + +# Describe the test +testDescript = 'Test with binary models values ' + +# Define the causal model. +# Each random variable has the following fields: +# - Name +# - List of Parents +# - isObserved (Optional, default True) +# - Data Type (Optional, default 'Numeric') +model = [('X', []), + ('Y', ['X']) + ] + +# varEquations = [ +# 'X = 1 if uniform(0,1) > 0.7 else 0', +# 'U = uniform(0,1)', +# # 'Y = 0 if U < 0.4 and X == 0 else 1 if U >= 0.4 and X == 0 else 0 if U > 0.1 and X == 1 else 1 if U <= 0.1 and X==1 else 0' +# # 'Y = 0 if U < 0.5 and X == 1 else 1 if 0.5 < U < 0.9 and X == 1 else 0 if U < 0.2 and X == 0 else 1 if 0.2 < U < 0.4 and X == 0 else 2' +# 'Y = 1^X if U > 0.1 else 0^X' +# ] + +varEquations = [ + 'X = 1 if uniform(0,1) > 0.7 else 0', + 'U = uniform(0,1)', + 'Y = 1^X if U > 0.1 else 0^X' +] diff --git a/because/probability/ucm/models/categTest2.py b/because/probability/ucm/models/categTest2.py new file mode 100644 index 0000000..4594c04 --- /dev/null +++ b/because/probability/ucm/models/categTest2.py @@ -0,0 +1,48 @@ +# ---------------------------------------------------------------------------- +# Model Definition +# ---------------------------------------------------------------------------- +from itertools import permutations +from numpy.random import choice, seed + +# Initialize any variables here +seed(1) +genderDist = [0.4, 0.6] +sizes = ["xs", "s", "m", "l", "xl"] +base_dist = [0.05, 0.1, 0.15, 0.3, 0.4] +dist_perm = list(permutations(base_dist)) +sizeProb = { + 'm': dist_perm[choice(range(len(dist_perm)))], + 'f': dist_perm[choice(range(len(dist_perm)))] +} + +#sizeProb = { +# 'm': [0.05, 0.15, 0.4, 0.3, 0.1], +# 'f': [0.1, 0.3, 0.4, 0.15, 0.05] +# } + +# Describe the test +testDescript = 'Test with 2 trinary models variables' + +# Define the causal model. +# Each random variable has the following fields: +# - Name +# - List of Parents +# - isObserved (Optional, default True) +# - Data Type (Optional, default 'Numeric') +# model = [('X', [], 'Categorical'), +# ('Y', ['X'], 'Categorical) +# ] + +# varEquations = [ +# 'X = choice(range(1,4), p=[0.25,0.25,0.5])', +# 'Y = X if uniform(0,1) > 0.9 else choice(range(1,4))' +# ] + +# Gender Equations +model = [('gender', []), + ('size', ['gender']) + ] +varEquations = [ + 'gender = choice(["m", "f"], p=genderDist)', + 'size = choice(sizes, p=sizeProb[gender])' +] diff --git a/because/probability/ucm/models/trinaryCateg.py b/because/probability/ucm/models/trinaryCateg.py new file mode 100644 index 0000000..a19315d --- /dev/null +++ b/because/probability/ucm/models/trinaryCateg.py @@ -0,0 +1,28 @@ +# ---------------------------------------------------------------------------- +# Model Definition +# ---------------------------------------------------------------------------- + +# Initialize any variables here +t = 0 + +# Describe the test +testDescript = 'Test with trinary models variables' + +# Define the causal model. +# Each random variable has the following fields: +# - Name +# - List of Parents +# - isObserved (Optional, default True) +# - Data Type (Optional, default 'Numeric') +model = [('X', []), + ('Y', ['X']) + ] + +varEquations = [ + 'U = uniform(0,1)', + 'X = 1', + 'X = 2 if U > 0.25 else X', + 'X = 3 if U > 0.5 else X', + # 'X = choice(range(1, 4))', + 'Y = X if uniform(0,1) > 0.5 else choice(range(1,4))', +] diff --git a/because/probability/ucm/ucVarTest.py b/because/probability/ucm/ucVarTest.py new file mode 100644 index 0000000..4c0b0c0 --- /dev/null +++ b/because/probability/ucm/ucVarTest.py @@ -0,0 +1,74 @@ +import pprint +from because.probability.prob import ProbSpace +from because.synth import Reader +from because.visualization import cmodel +from because.probability.ucm.ucm import UCVar, CategVar + +# Example of using the UCVar Class + +''' +-- Initialize the variables with a base distribution and any parent variables. +Base distributions should be a real probability distribution, with values adding to 1. +Parent variables should be initialized first, followed by child variables. +The parents of each variable should be passed when initializing each child variable. + +''' + +varA = UCVar(base_distribution=[0.8, 0.2], values=['male', 'female']) +varB = UCVar(base_distribution=[0.1, 0.1, 0.8], values=['small', 'medium', 'large'], parent=varA) +varC = UCVar(base_distribution=[0.4, 0.6], values=['yes', 'no'], parent=[varA, varB]) + +''' +For each variable, we are able to print the corresponding output values, distribution, or parent values. +''' +print(f"\nParent Values (possible inputs): \n\t{varC.parent_vals}") +print(f"\nPossible output values: \n\t{varC.values}") +print("\nDistribution of C (given (A,B) pair) : \n\t") +pprint.pprint(varC.distribution) + +''' +Generating values. +If the variable is endogenous, then pass the values of the parent variables +(and in the same order as they were passed during initialization). +''' + +A = varA.get_value() +B = varB.get_value(A) +C = varC.get_value([A, B]) + +print(f"\nGenerated values: \n\tA:{A}, B:{B}, C:{C}") + +''' +Output values which are not initialized will be inferred from the base distribution. +''' +varD = UCVar(base_distribution=[0.25, 0.25, 0.5], parent=varB) +print(f"\nPossible output values: {varD.values}") + +''' +There is also a CategVar class, with distribution explicitly defined by parent vars. +Intened to be a non-UC categorical variable but wasn't used much; not well-fleshed out. +''' +dist = { + 'male': [0.8, 0.2], + 'female': [0.6, 0.4] +} +varE = CategVar(distribution=dist, parent=varA) + +print("\nDistribution of E (given A) : \n\t") +pprint.pprint(varE.distribution) +print(f"\nPossible output values: {varE.values}") + +''' +For doing testing and discovery, read dataset into a ProbSpace object and use testDirection. +''' +# Read in model, define models variables +filename = "probability/ucm/models/M2.csv" +ds = Reader(filename) +ps = ProbSpace(ds.varData, categorical=['A', 'B', 'C']) + +# To test a particular direction +out = ps.testDirection('A', 'B') +print(f"\nCalculated rho value: {out}") + +# To perform discovery on target variables and show discovered the causal graph +cmodel.show(probspace=ps, targetSpec=['A','B','C'], sensitivity=10, power=5, edgeLabels='rho', verbosity=1) diff --git a/because/probability/ucm/ucm.py b/because/probability/ucm/ucm.py new file mode 100644 index 0000000..faa9369 --- /dev/null +++ b/because/probability/ucm/ucm.py @@ -0,0 +1,289 @@ +import itertools +import random +import pandas as pd +import numpy as np +import scipy.stats as stats +from pprint import pprint +from because.utils import vprint + + +verbosity = 0 +''' +Uniform channel variable class. +Auto-initializes the distributions for the variable given a base distribution. +Each parent value(s) has a defined distribution (which may or may not be unique) + corresponding to a uniform channel -- each distribution is a permutation of + the base distribution. +Values can be generated from the distributions corresponding to the parent values, +if applicable. + +''' +class UCVar: + def __init__(self, base_distribution, values=None, parent=None, noise=0): + self.base_distribution = base_distribution + + if type(values) is list: + self.values = values + else: + self.values = [i for i in range(len(base_distribution))] + if parent is not None: + if type(parent) in (UCVar, CategVar) or (type(parent) is list and len(parent) == 1): + self.distribution = get_dist_dict(parent.values, self.base_distribution, noise) + + elif type(parent) is list and len(parent) > 1: + self.parent = parent + # self.parent_size = [parent.size() for parent in self.parent] + self.parent_vals = [parent.values for parent in self.parent] + self.distribution = get_dist_dict(self.parent_vals, self.base_distribution, noise) + + else: + self.distribution = base_distribution + + ''' + Generate a random value from the distribution corresponding to input parent values. + ''' + def get_value(self, value=None): + vprint(2, verbosity, f"Value: {value}") + vprint(2, verbosity, f"Variable distribution: {self.distribution}") + if value is not None: + assert type(self.distribution) is dict, "Must have parent variables defined" + if type(value) is list: + c = np.random.choice(self.values, p=self.distribution[tuple(value)]) + else: + c = np.random.choice(self.values, p=self.distribution[value]) + else: + c = np.random.choice(self.values, p=self.distribution) + vprint(2, verbosity, f"choice: {c}") + return c + + def size(self): + return len(self.base_distribution) + + +''' +Heuristic variable class for models variables; not well-defined, + mainly for testing with UCVar and non-uniform channel distributions. +Distribution dictionary should be of the form + {parent_value_1: [weight_1, weight_2, ..., weight_n], + ... , + parent_value_m: [weight_1, weight_2, ..., weight_n]}. +''' +class CategVar: + def __init__(self, distribution, values=None, parent=None): + self.distribution = distribution + self.parent = parent + if values is not None: + self.values = values + elif parent is not None: + self.values = range(len(list(distribution.values())[0])) + else: + self.values = range(len(distribution)) + + ''' + Generate a random value from the distribution corresponding to input parent values.''' + def get_value(self, value=None): + if value is not None: + assert type(self.distribution) is dict, "Must have parent variables defined" + if type(value) is list: + c = np.random.choice(self.values, p=self.distribution[tuple(value)]) + else: + c = np.random.choice(self.values, p=self.distribution[value]) + else: + c = np.random.choice(self.values, p=self.distribution) + vprint(3, verbosity, f"Value choice: {c}") + return c + + +''' +Performs the uniform channel test as described in UCM paper, obtaining a p-value for both directions. +Each parameter A and B should correspond to a list of observations for a single variable. +Alpha value can be adjusted for confidence, default value is 0.05. +AMap and BMap to remap values to string names; cosmetic and for debugging. +Returns rho value to determine directionality and confidence, and identifiability boolean. +''' +def uniform_channel_test(A, B, alpha=0.05, AMap=None, BMap=None, limit=None): + # if limit is not None and limit > len(A): + # idx = random.sample(range(len(A)), 10000) + # print(type(A)) + # A = A[idx] + # B = B[idx] + + ab_pval = p_val(A, B, AMap, BMap) + ba_pval = p_val(A, B, AMap, BMap, reversed=True) + # ba_pval = p_val(B, A, BMap, AMap) + + vprint(1, verbosity, f"\n\t**P-values** \nForward: {ab_pval} \nBackward:{ba_pval}") + + ''' Alpha may not be needed if we're using a rho value to determine direction; + - if both are significant (high magnitude p), then rho goes towards 0. + - if neither is signification (low magnitude p), then rho goes towards 0. + - Otherwise, one will have a large p value and the other small, so rho is useful. + ''' + + rho = ab_pval - ba_pval + vprint(1, verbosity, f"Rho-value: {rho}") + + # Identifiable if tne direction is significant and the other is not + if (ab_pval > alpha > ba_pval) or (ab_pval < alpha < ba_pval): + identifiable = True + else: + identifiable = False + vprint(1, verbosity, f"identifiable: {identifiable}") + return rho, identifiable + + +''' +Performs the uniform channel test as described in UCM paper, for two variables. +A and B should each be a list of observations for a particular variable. + A[i] and B[i] correspond to the i-th observation of the A and B variables. +Generates and returns a p-value +''' +def p_val(A, B, AMap=None, BMap=None, reversed = False): + + from scipy.stats.contingency import crosstab + # if len(A) > 11000: + # idx = random.sample(range(len(A)), 10000) + # # print(idx) + # A = A[idx] + # B = B[idx] + # + # # A = A[]:10000 + # # B = B[:10000] + + if reversed: + A, B = B, A + + a_size = len(np.unique(A)) + b_size = len(np.unique(B)) + n = len(A) + + # Chunk mostly for seeing conditional prob dist when debugging + if reversed: + df = pd.DataFrame({ + 'B': A, + 'A': B + }) + cond_a = (df.groupby('B')['A'].value_counts() / df.groupby('B')['A'].count()).unstack().fillna(0) + + if BMap is not None: + cond_a.index = [BMap[i] for i in cond_a.index] + if AMap is not None: + cond_a.columns = [AMap[i] for i in cond_a.columns] + vprint(2, verbosity, f"Cond prob Var1|Var2: \n{cond_a}") + else: + df = pd.DataFrame({ + 'A': A, + 'B': B + }) + + cond_b = (df.groupby('A')['B'].value_counts() / df.groupby('A')['B'].count()).unstack().fillna(0) + if AMap is not None: + cond_b.index = [AMap[i] for i in cond_b.index] + if BMap is not None: + cond_b.columns = [BMap[i] for i in cond_b.columns] + + vprint(2, verbosity, f"Cond prob Var2|Var1: \n{cond_b}") + + # Obtain the contingency table, sorted rows of observed values + cont_table = crosstab(A, B)[1] + cont_table_sort = [sorted(cont_table[i], reverse=True) for i in range(a_size)] + vprint(4, verbosity, f"Contingency table: \n{cont_table_sort}") + + # Calculate MLE from columns of the sorted contingency table + cat_counts = [[cont_table_sort[i][j] for i in range(a_size)] for j in range(b_size)] # Group by size category + mle = [sum(i) / n for i in cat_counts] + + # Obtain the expected values (sorted table) + N_a = [sum(cont_table[i]) for i in range(a_size)] + exp_cont_table = [[N_a[i] * mle[j] for j in range(b_size)] for i in range(a_size)] + vprint(4, verbosity, f"Expected table: \n{exp_cont_table}") + + # Calculate a G-score + summand = [cont_table_sort[x][y] * np.log((cont_table_sort[x][y] / (exp_cont_table[x][y] + 0.000000001)) + 0.000000001) + for x in range(a_size) for y + in range(b_size)] + vprint(5, verbosity, '\tSummand: {summand}') + g_squared = 2 * sum(summand) + vprint(5, verbosity, "\tg-squared: {g_squared}") + + # Calculate the corresponding p-value from g-squared statistic + dof = (a_size - 1) * (b_size - 1) + p_value = 1 - stats.chi2.cdf(g_squared, df=dof) + + return p_value + + +# For initializing noisy UC probability distributions within models; Not really needed anymore +def get_noisy_perm(base_dist, noise): + # print(base_dist) + # print(sum(base_dist)) + # assert sum(base_dist) == 1, "Distribution must sum to 1" + + from random import uniform, seed + from numpy.random import choice + from itertools import permutations + # seed(1) + + # Generate noise + noise = [uniform(0, noise) for i in range(len(base_dist))] + + # Add noise to a permutation + perms = list(permutations(base_dist)) + unnorm_dist = np.array(perms[choice(range(len(perms)))]) + noise + + # Normalize distribution + norm_dist = [float(i) / sum(unnorm_dist) for i in unnorm_dist] + + # print(norm_dist) + + return norm_dist + +# Auto-generates a (UNIFORM CHANNEL) distribution dictionary dependent on possible parent values and base distribution +# For generating models variable values +def get_dist_dict(parent_vals, base_dist, noise=0.0): + dist_dict = dict() + # multiple parents + if type(parent_vals[0]) is list: + prod = itertools.product(*parent_vals) + for elem in prod: + dist_dict[elem] = get_noisy_perm(base_dist, noise) + else: # single parent + for val in parent_vals: + dist_dict[val] = get_noisy_perm(base_dist, noise) + # if verbosity >= 3: + # pprint(dist_dict) + return dist_dict + + + +if __name__ == "__main__": + + # for i in range(1): + # print(f"i = {i}") + # # d = get_noisy_perm([0.1, 0.1, 0.8]) + # get_dist_dict(2, [0.1, 0.1, 0.8]) + # # print(np.random.choice(range(3), p=d)) + + # CatA = UCVar([0.1, 0.1, 0.8]) + # CatC = UCVar([0.4, 0.6]) + # CatB = UCVar([0.2, 0.8], parent=[CatA, CatC]) + + + # for i in range(10): + # A = CatA.get_value() + # C = CatC.get_value() + # # print(A) + # B = CatB.get_value([A, C]) + + CatB = CategVar([0.4, 0.5, 0.1]) + + CatA = UCVar([0.25, 0.25, 0.5], parent=CatB) + CatC = UCVar([0.2, 0.8], parent=[CatA, CatB]) + for i in range(10): + B = CatB.get_value() + A = CatA.get_value(B) + # print(A) + C = CatC.get_value([A, B]) + print("VALUES: ", A, B, C) + + diff --git a/because/visualization/cmodel.py b/because/visualization/cmodel.py index e9c7704..0a6ee2c 100644 --- a/because/visualization/cmodel.py +++ b/because/visualization/cmodel.py @@ -73,6 +73,8 @@ def show(dataPath='', numRecs=0, targetSpec=[], condSpec=[], controlFor=[], gtyp rvs = cg.getRVs() if edgeLabels == 'mde': elText = 'Maximum Direct Effect' + elif edgeLabels == 'rho': + elText = 'Rho-value' else: elText = 'Correlation' vprint(4, verbosity, 'Showing', elText, 'for edge labels') @@ -86,6 +88,8 @@ def show(dataPath='', numRecs=0, targetSpec=[], condSpec=[], controlFor=[], gtyp effect = cg.MDE(parent, var) if corr < 0: effect *= -1 + elif edgeLabels == 'rho': + effect = cg.getEdgeProp(link, 'dir_rho') else: effect = corr edgeVals[link] = effect