private static TThis BuildSubautomaton(IReadOnlyList <State> states, IReadOnlyList <State> topologicalOrder, int group, HashSet <int> subgraph)
{
var weightsFromRoot = ComputeWeightsFromRoot(states.Count, topologicalOrder, group);
var weightsToEnd = ComputeWeightsToEnd(states.Count, topologicalOrder, group);
var subautomaton = new TThis();
var stateMapping = subgraph.ToDictionary(x => x, _ => subautomaton.AddState());
var hasNoIncomingTransitions = new HashSet <int>(subgraph);
// copy the automaton and find states without incoming transitions.
foreach (var stateIndex in subgraph)
{
var newSourceState = stateMapping[stateIndex];
for (int i = 0; i < states[stateIndex].TransitionCount; i++)
{
var transition = states[stateIndex].GetTransition(i);
if (transition.Group != group)
{
continue;
}
hasNoIncomingTransitions.Remove(transition.DestinationStateIndex);
newSourceState.AddTransition(
transition.ElementDistribution,
transition.Weight,
stateMapping[transition.DestinationStateIndex]);
}
}
var correctionFactor = Weight.Zero;
// mark start and end states, modulo paths bypassing the automaton.
foreach (var stateIndex in subgraph)
{
var newSourceState = stateMapping[stateIndex];
// consider start states
var weightFromRoot = newSourceState.TransitionCount > 0 ? weightsFromRoot[stateIndex] : Weight.Zero;
if (!weightFromRoot.IsZero)
{
subautomaton.Start.AddEpsilonTransition(weightFromRoot, newSourceState);
}
// consider end states
var weightToEnd = !hasNoIncomingTransitions.Contains(stateIndex) ? weightsToEnd[stateIndex] : Weight.Zero;
if (!weightToEnd.IsZero)
{
newSourceState.SetEndWeight(weightToEnd);
}
correctionFactor = Weight.Sum(correctionFactor, Weight.Product(weightFromRoot, weightToEnd));
}
if (!correctionFactor.IsZero)
{
throw new Exception("Write a unit test for this case. Code should be fine.");
}
var epsilonWeight = Weight.AbsoluteDifference(weightsToEnd[topologicalOrder[0].Index], correctionFactor);
subautomaton.Start.SetEndWeight(epsilonWeight);
return(subautomaton);
}
/// <summary>
/// Computes a set of outgoing transitions from a given state of the determinization result.
/// </summary>
/// <param name="sourceState">The source state of the determinized automaton represented as
/// a set of (stateId, weight) pairs, where state ids correspond to states of the original automaton.</param>
/// <returns>
/// A collection of (element distribution, weight, weighted state set) triples corresponding to outgoing transitions from <paramref name="sourceState"/>.
/// The first two elements of a tuple define the element distribution and the weight of a transition.
/// The third element defines the outgoing state.
/// </returns>
protected override List <(DiscreteChar, Weight, Determinization.WeightedStateSet)> GetOutgoingTransitionsForDeterminization(
Determinization.WeightedStateSet sourceState)
{
const double LogEps = -35; // Don't add transitions with log-weight less than this as they have been produced by numerical inaccuracies
// Build a list of numbered non-zero probability character segment bounds (they are numbered here due to perf. reasons)
var segmentBounds = new List <ValueTuple <int, TransitionCharSegmentBound> >();
int transitionsProcessed = 0;
foreach (KeyValuePair <int, Weight> stateIdWeight in sourceState)
{
var state = this.States[stateIdWeight.Key];
foreach (var transition in state.Transitions)
{
AddTransitionCharSegmentBounds(transition, stateIdWeight.Value, segmentBounds);
}
transitionsProcessed += state.Transitions.Count;
}
// Sort segment bounds left-to-right, start-to-end
var sortedIndexedSegmentBounds = segmentBounds.ToArray();
if (transitionsProcessed > 1)
{
Array.Sort(sortedIndexedSegmentBounds, CompareSegmentBounds);
int CompareSegmentBounds((int, TransitionCharSegmentBound) a, (int, TransitionCharSegmentBound) b) =>
a.Item2.CompareTo(b.Item2);
}
// Produce an outgoing transition for each unique subset of overlapping segments
var result = new List <(DiscreteChar, Weight, Determinization.WeightedStateSet)>();
Weight currentSegmentStateWeightSum = Weight.Zero;
var currentSegmentStateWeights = new Dictionary <int, Weight>();
foreach (var sb in segmentBounds)
{
currentSegmentStateWeights[sb.Item2.DestinationStateId] = Weight.Zero;
}
var activeSegments = new HashSet <TransitionCharSegmentBound>();
int currentSegmentStart = char.MinValue;
foreach (var tup in sortedIndexedSegmentBounds)
{
TransitionCharSegmentBound segmentBound = tup.Item2;
if (currentSegmentStateWeightSum.LogValue > LogEps && currentSegmentStart < segmentBound.Bound)
{
// Flush previous segment
char segmentEnd = (char)(segmentBound.Bound - 1);
int segmentLength = segmentEnd - currentSegmentStart + 1;
DiscreteChar elementDist = DiscreteChar.InRange((char)currentSegmentStart, segmentEnd);
var destinationState = new Determinization.WeightedStateSet();
foreach (KeyValuePair <int, Weight> stateIdWithWeight in currentSegmentStateWeights)
{
if (stateIdWithWeight.Value.LogValue > LogEps)
{
Weight stateWeight = Weight.Product(stateIdWithWeight.Value, Weight.Inverse(currentSegmentStateWeightSum));
destinationState.Add(stateIdWithWeight.Key, stateWeight);
}
}
Weight transitionWeight = Weight.Product(Weight.FromValue(segmentLength), currentSegmentStateWeightSum);
result.Add((elementDist, transitionWeight, destinationState));
}
// Update current segment
currentSegmentStart = segmentBound.Bound;
if (segmentBound.IsStart)
{
activeSegments.Add(segmentBound);
currentSegmentStateWeightSum = Weight.Sum(currentSegmentStateWeightSum, segmentBound.Weight);
currentSegmentStateWeights[segmentBound.DestinationStateId] = Weight.Sum(currentSegmentStateWeights[segmentBound.DestinationStateId], segmentBound.Weight);
}
else
{
Debug.Assert(currentSegmentStateWeights.ContainsKey(segmentBound.DestinationStateId), "We shouldn't exit a state we didn't enter.");
activeSegments.Remove(segmentBounds[tup.Item1 - 1].Item2); // End follows start in original.
if (double.IsInfinity(segmentBound.Weight.Value))
{
// Cannot subtract because of the infinities involved.
currentSegmentStateWeightSum = activeSegments.Select(sb => sb.Weight).Aggregate(Weight.Zero, (acc, w) => Weight.Sum(acc, w));
currentSegmentStateWeights[segmentBound.DestinationStateId] =
activeSegments.Where(sb => sb.DestinationStateId == segmentBound.DestinationStateId).Select(sb => sb.Weight).Aggregate(Weight.Zero, (acc, w) => Weight.Sum(acc, w));
}
else
{
currentSegmentStateWeightSum = activeSegments.Count == 0 ? Weight.Zero : Weight.AbsoluteDifference(currentSegmentStateWeightSum, segmentBound.Weight);
Weight prevStateWeight = currentSegmentStateWeights[segmentBound.DestinationStateId];
currentSegmentStateWeights[segmentBound.DestinationStateId] = Weight.AbsoluteDifference(
prevStateWeight, segmentBound.Weight);
}
}
}
return(result);
}
