public void WriteProbsToConsole()
{
foreach (var keyValuePair in _probs)
{
Console.Out.WriteLine($"{{{string.Join(",", SubsetUtils.FromIndex(_randomVariables, keyValuePair.Key).Select(v => v.Name))}}}: {keyValuePair.Value}");
}
}
/// <summary>
/// Identifies the conditional independencies between the given variables by exhaustive use of the mathematical definition of independency and probability distribution calculation
/// </summary>
private void CalculatePairIndependencies(IList <RandomVariable> variablesToUse)
{
for (var i = 0; i < variablesToUse.Count; i++)
{
for (var j = i + 1; j < variablesToUse.Count; j++)
{
var first = variablesToUse[i];
var second = variablesToUse[j];
if (IsIndependent(first, second))
{
Console.Out.WriteLine($"Variables {first.Name} and {second.Name} are independent");
AddIndependency(first, second);
}
for (var k = 1; k < variablesToUse.Count - 1 && k <= _config.MaxConditionSize; k++)
{
var subsets =
SubsetUtils.AllSubsets(
Enumerable.Range(0, variablesToUse.Count).Except(new[] { i, j })
.ToList(), k);
foreach (var indexSubset in subsets)
{
var curVars = indexSubset.Select(index => variablesToUse[index]).ToList();
if (IsConditionalIndependent(first, second, new List <RandomVariable>(curVars)))
{
Console.Out.WriteLine(
$"Variables {first.Name} and {second.Name} are independent given {string.Join(", ", curVars)}");
AddIndependency(first, second, curVars);
}
}
}
}
}
}
/*
* Calculates the union with the inclusion/exclusion principle, but with one more indirection:
* It calculates the probablity of (A u B u C), but A, B, C are just representation sets,
* because each consists of intersections of various random variables.
* So e.g. for A = P(R1, R2), B = P(R2,R3,R4) and C = P(R1,R3,R5) it actually calculates:
* A u B u C = P(R1,R2) u P(R2,R3,R4) u P(R1,R3,R5)
*/
private Probability CalculateUnionOfIntersectionSets(IList <ISet <RandomVariable> > variables)
{
var sum = Probability.Zero;
for (var k = 0; k < variables.Count; k++)
{
var innerSum = Probability.Zero;
var currentIndices = SubsetUtils.AllSubsets(Enumerable.Range(0, variables.Count).ToList(), k + 1);
foreach (var indexSubset in currentIndices)
{
// get the current representation sets, e.g. A, B
var currentVariableSets = indexSubset.Select(index => variables[index]).ToList();
// get the set of the actual random variables, e.g. R1,R2,R3,R4
var currentVariables = currentVariableSets.SelectMany(x => x).Distinct().ToList();
innerSum += GetProbability(currentVariables);
}
if (k % 2 == 0)
{
sum += innerSum;
}
else
{
sum -= innerSum;
}
}
return(sum);
}
/// <summary>
/// Returns the probability for the given random variables. If it is not present yet, it is calculated first.
/// All access to _probs should be through this method!
/// </summary>
/// <param name="variables">random variables for the distribution</param>
/// <returns></returns>
private Probability GetProbability(ICollection <RandomVariable> variables)
{
var index = SubsetUtils.GetIndex(variables, _randomVariables);
if (!_probs.ContainsKey(index))
{
_probs[index] = CalculateProbability(variables.ToList());
if (!string.IsNullOrWhiteSpace(_config.ProbabilitySerializationFilePath))
{
SerializeCurrentProbabilities();
}
}
return(_probs[index]);
}
private void CalculateFurtherDccaIndependencies()
{
// let A be a fault that is not part of a minimal critical set or a state
// check for every A:
// is A independent of the hazard given the minimal critical sets
// is A independent of the hazard given all subsets of other A's like this one
var allFaultsInCriticalSets = _minimalCriticalSets.SelectMany(mcs => mcs.FaultVariables).ToList();
var faultsInNoMcsAndStates = new List <RandomVariable>(_faults.Except(allFaultsInCriticalSets)).ToList();
faultsInNoMcsAndStates.AddRange(_states);
var i = 0;
foreach (var faultOrState in faultsInNoMcsAndStates)
{
if (IsIndependent(_hazard, faultOrState))
{
Console.Out.WriteLine(
$"Variables {_hazard.Name} and {faultOrState.Name} are independent");
AddIndependency(_hazard, faultOrState);
}
if (IsConditionalIndependent(_hazard, faultOrState, new List <RandomVariable>(_minimalCriticalSets)))
{
Console.Out.WriteLine(
$"Variables {_hazard.Name} and {faultOrState.Name} are independent given {string.Join(", ", _minimalCriticalSets)}");
AddIndependency(_hazard, faultOrState, _minimalCriticalSets);
}
for (var k = 1; k < faultsInNoMcsAndStates.Count - 1 && k <= _config.MaxConditionSize; k++)
{
var subsets =
SubsetUtils.AllSubsets(
Enumerable.Range(0, faultsInNoMcsAndStates.Count).Except(new[] { i })
.ToList(), k);
foreach (var indexSubset in subsets)
{
var curVars = indexSubset.Select(index => faultsInNoMcsAndStates[index]).ToList();
if (IsConditionalIndependent(_hazard, faultOrState, new List <RandomVariable>(curVars)))
{
Console.Out.WriteLine(
$"Variables {_hazard.Name} and {faultOrState.Name} are independent given {string.Join(", ", curVars)}");
AddIndependency(_hazard, faultOrState, curVars);
}
}
}
i++;
}
}
private void DeserializeProbabilities()
{
using (var file = File.OpenText(_config.ProbabilityDeserializationFilePath))
{
var serializer = new JsonSerializer();
var probs = (ProbabilitySerialization)serializer.Deserialize(file, typeof(ProbabilitySerialization));
foreach (var keyValuePair in probs.Probs)
{
var storedIndex = keyValuePair.Key;
var storedRandomVariables = SubsetUtils.FromIndex(probs.RandomVariables, storedIndex);
var realRandomVariables = _randomVariables.Where(rvar => storedRandomVariables.Contains(rvar.Name)).ToList();
_probs[SubsetUtils.GetIndex(realRandomVariables, _randomVariables)] = keyValuePair.Value;
if (realRandomVariables.Count == 1)
{
realRandomVariables[0].Probability = new[] { keyValuePair.Value, keyValuePair.Value.Complement() };
}
}
}
}
/// <summary>
/// Calculates all probability distributions of all subsets of the random variables.
/// Use with caution!
/// </summary>
public void CalculateTrueProbabilities()
{
// Iterate through all 2^n random variables
for (var i = 1; i < (1 << _randomVariables.Count); i++)
{
var currentVars = new HashSet <RandomVariable>();
for (var j = 0; j < _randomVariables.Count; j++)
{
// is the jth random variable present in the current subset?
// it is, if there is a 1 at the jth bit from the right side
// so 'and' i and 2^j and test if the result is greater than zero
if ((i & (1 << j)) > 0)
{
currentVars.Add(_randomVariables[j]);
}
}
_probs[SubsetUtils.GetIndex(currentVars, _randomVariables)] = CalculateProbability(currentVars.ToList());
}
WriteProbsToConsole();
}
