Post date: Apr 15, 2016 10:15:53 AM
The "Alyson problem" is having sample data (successes and failures) for both the inputs and outputs of a logical gate. Suppose C = A & B. How do I infer P(C), as well as P(A) and P(B), given numbers of events n out of N trials for events A, B and C? Coolen and Troffaes (2009, attached below) solved this problem with Imprecise Dirichlet Models. The answers are different, depending on whether one assumes that A and B are independent or makes no assumption about their dependence.
We'd like to convert the solutions of Frank and Matthias to the analogous c-box solutions, and generally expand them into practical analytical software that takes as input whatever sample data is available at any node in a fault tree and projects that information up and down the tree to make the best-possible estimates for the probabilities of the top and intermediary events. The software should be able to handle at least the independent and Frechet cases for each set of conjunctands/disjunctands. Such software would be our answer to a Bayesian belief network (only our approach would actually make sense and be able to work in practice!).
Below are implementations of the Coolen−Troffaes solutions, which at first (and maybe still?) seemed to yield counterintuitive results when compared against simple special and limiting cases. Their solutions are giving us interval bounds on the means of the c-boxes. I think that we instead want the whole c-boxes, from which means and everything else are easy to obtain.
na = 10
Na = 100
nb = 2
Nb = 2000
nc = 0
Nc = 1000
Icoolen.troffaes = function(na,Na,nb,Nb,nc,Nc,s=1) {
# assumes a and b are independent
nanc = na + nc
nbnc = nb + nc
nbNc = nb + Nc
naNc = na + Nc
nasnc = na + s + nc
nbsnc = nb + s + nc
nasNc = na + s + Nc
nbsNc = nb + s + Nc
NasNc = Na + s + Nc
NbsNc = Nb + s + Nc
Nasnc = Na + s + nc
Nbsnc = Nb + s + nc
a = interval(nanc/NasNc, nasnc/Nasnc)
b = interval(nbnc/NbsNc, nbsnc/Nbsnc)
c = interval(max(min((nanc/Nasnc) * (nbnc/NbsNc), (nanc/NasNc) * (nbNc/NbsNc)),min((nbnc/Nbsnc) * (nanc/NasNc),(nbnc/NbsNc) * (naNc/NasNc))),min(max((nasnc/Nasnc) * (nbsnc/NbsNc),(nasnc/NasNc) * (nasnc/Nasnc)),max((nbsnc/Nbsnc) * (nasnc/NasNc),(nbsnc/NbsNc) * (nasNc/NasNc))))
list(a=a, b=b, c=c)
}
coolen.troffaes = function(na,Na,nb,Nb,nc,Nc,s=1) {
# makes no assumption about dependence between a and b
N = Na + Nb + Nc
a = interval((na+nc)/(N+s), (na+Nb+Nc+s)/(N+s))
b = interval((nb+nc)/(N+s), (nb+Na+Nc+s)/(N+s))
c = interval((nc)/(N+s), (na+nb+nc+s)/(N+s))
list(a=a, b=b, c=c)
}
Icoolen.troffaes(na,Na,nb,Nb,nc,Nc)
coolen.troffaes(na,Na,nb,Nb,nc,Nc)
//////////////////////////////////////////////////////////////////////////////////////////
// checks in Risk Calc
na = 10
Na = 100
nb = 2
Nb = 2000
nc = 0
Nc = 0
nanc = na + nc
nbnc = nb + nc
nbNc = nb + Nc
naNc = na + Nc
nasnc = na + s + nc
nbsnc = nb + s + nc
nasNc = na + s + Nc
nbsNc = nb + s + Nc
NasNc = Na + s + Nc
NbsNc = Nb + s + Nc
Nasnc = Na + s + nc
Nbsnc = Nb + s + nc
a = [nanc/NasNc, nasnc/Nasnc]
b = [nbnc/NbsNc, nbsnc/Nbsnc]
c = [max(min((nanc/Nasnc) * (nbnc/NbsNc), (nanc/NasNc) * (nbNc/NbsNc)),min((nbnc/Nbsnc) * (nanc/NasNc),(nbnc/NbsNc) * (naNc/NasNc))),min(max((nasnc/Nasnc) * (nbsnc/NbsNc),(nasnc/NasNc) * (nasnc/Nasnc)),max((nbsnc/Nbsnc) * (nasnc/NasNc),(nbsnc/NbsNc) * (nasNc/NasNc)))]
a;b;c
cless_a = [na/(Na+s),(na+s)/(Na+s)]
cless_b = [nb/(Nb+s),(nb+s)/(Nb+s)]
cless_c = [(na/(Na+s))*(nb/(Nb+s)),((na+s)/(Na+s))*((nb+s)/(Nb+s))]
cless_a;cless_b;cless_c
na = 0
Na = 0
nb = 0
Nb = 0
nc = 2
Nc = 1000
nanc = na + nc
nbnc = nb + nc
nbNc = nb + Nc
naNc = na + Nc
nasnc = na + s + nc
nbsnc = nb + s + nc
nasNc = na + s + Nc
nbsNc = nb + s + Nc
NasNc = Na + s + Nc
NbsNc = Nb + s + Nc
Nasnc = Na + s + nc
Nbsnc = Nb + s + nc
a = [nanc/NasNc, nasnc/Nasnc]
b = [nbnc/NbsNc, nbsnc/Nbsnc]
c = [max(min((nanc/Nasnc) * (nbnc/NbsNc), (nanc/NasNc) * (nbNc/NbsNc)),min((nbnc/Nbsnc) * (nanc/NasNc),(nbnc/NbsNc) * (naNc/NasNc))),min(max((nasnc/Nasnc) * (nbsnc/NbsNc),(nasnc/NasNc) * (nasnc/Nasnc)),max((nbsnc/Nbsnc) * (nasnc/NasNc),(nbsnc/NbsNc) * (nasNc/NasNc)))]
a;b;c
conly_a = [nc/Nc,1]
conly_b = [nc/Nc,1]
conly_c = [(nc/(nc+s))*(nc/(Nc+s)),(nc+s)/(Nc+s)]
conly_a; conly_b; conly_c
# also consider solutions when the data are very abundant