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(); }