private BALSetting <A, S> CheckBALSideCondition(Func <Node <A, S>, StackSymbolSequenceSet <S> > sideSelector, Node <A, S> premise)
{
Assertion.Assert(SelfAndPredecessors().Contains(this), "the premise has to be a predecessor of the node");
var branch = GetBranchToHereFromExlusively(premise);
if (!branch.All(n => n.OperationToHere is Operation <A, S> .UNF))
{
return(null);
}
var branchWord = branch.Select(n => ((Operation <A, S> .UNF)n.OperationToHere).Symbol);
var premiseSide = sideSelector(premise);
var ownSide = sideSelector(this);
var premiseHeadTail = premiseSide.Get1HeadTailForm();
var expOwnHeads = premiseHeadTail.Head.StackSequenceSet.Select(stackSymbol => sda.ApplyWordToStackSymbolSequence(stackSymbol, branchWord)).ToList();
if (!CheckBALSideCondition1(expOwnHeads, premiseHeadTail.Tail))
{
return(null);
}
var expOwnExprUnflattend = expOwnHeads.Zip(premiseHeadTail.Tail.StackSequenceSet, (ownHead, tail) => ownHead.Multiply(tail)).ToList();
var epxOwnExpr = StackSymbolSequenceSet <S> .Flatten(expOwnExprUnflattend);
//Is it correct, that it is unnecessary to verify that the expression is in valid head/tail-form (that means that the
//heads only are admissible)? I think it is, as the 1-k-form of the premise is valid head/tail-form and according to Chapter 4 Proposition 4
//the derived expression should also be in valid head/tail-form
if (!ownSide.Equals(epxOwnExpr))
{
return(null);
}
if (CheckBALSideCondition2(expOwnHeads, premiseHeadTail.Head, branch))
{
var premiseHeads = premiseHeadTail.Head.StackSequenceSet.Select(x =>
{
Assertion.Assert(x.StackSequence.Count() == 1, "x should contain exactly one stack symbol");
return(x.StackSequence.First());
}).ToList();
return(new BALSetting <A, S>(premise, expOwnHeads, premiseHeads));
}
return(null);
}
private void ApplyBAL(Operation <A, S> .BAL.BalType balType, BALSetting <A, S> bALSetting)
{
var oppositeSideSelector = Operation <A, S> .BAL.GetOppositeSideSelector(balType);
var F = oppositeSideSelector(bALSetting.Premise);
var bottoms = bALSetting.PremiseHeads.Select(x => sda.ApplyWordToStackSymbolSequenceSet(F, sda.ShortestWordsOfStackSymbols[x])).ToList();
var op = Operation <A, S> .BAL.CreateInstanceOfType(balType, bottoms);
var child = new Node <A, S>(op, this, sda, symbols);
Children = new List <Node <A, S> >()
{
child
};
var modifiedSideUnflattend = bALSetting.OwnHeads.Zip(bottoms, (head, bottom) => head.Multiply(bottom)).ToList();
var modifiedSite = StackSymbolSequenceSet <S> .Flatten(modifiedSideUnflattend);
op.SetCorrespondingSide(child, modifiedSite, oppositeSideSelector(this));
}
/// <summary>
/// tries to bring this set and the other set into head/tail-form, so that both have the same tails
/// </summary>
/// <param name="other"></param>
/// <returns></returns>
internal Tuple <HeadTailForm <S> > TryToGetHeadTailForm(StackSymbolSequenceSet <S> other)
{
//FIXME: replace this whole function by another algo, as it will not work like this
var ownSetWithInvsereOrder = OrderByStackSequencesInverse();
var otherWithInverseOrder = other.OrderByStackSequencesInverse();
var setsOrderByLength = new List <StackSymbolSequenceSet <S> >()
{
ownSetWithInvsereOrder, otherWithInverseOrder
}.OrderBy(s => s.StackSequenceSet.Count()).ToList();
var headsOfSmallerSet = new List <StackSymbolSequence <S> >();
var headsOfLongerSet = new List <StackSymbolSequence <S> >();
var tails = new List <StackSymbolSequence <S> >();
for (int i = 0; i < setsOrderByLength.First().StackSequenceSet.Count(); i++)
{
var firstStackSequence = setsOrderByLength[0].StackSequenceSet.ElementAt(i);
var secondStackSequence = setsOrderByLength[1].StackSequenceSet.ElementAt(i);
var tail = firstStackSequence.GetLongestPossibleCommonTail(secondStackSequence);
headsOfSmallerSet.Add(firstStackSequence.GetHeadWithRespectToTail(tail));
headsOfLongerSet.Add(secondStackSequence.GetHeadWithRespectToTail(tail));
tails.Add(tail);
}
var tailsOrderedByLength = tails.OrderByDescending(t => t.StackSequence.Count());
var smallerLentgh = setsOrderByLength[0].StackSequenceSet.Count();
var remaining = setsOrderByLength[1].StackSequenceSet.Count() - smallerLentgh;
for (int i = 0; i < remaining; i++)
{
var next = setsOrderByLength[1].StackSequenceSet.ElementAt(smallerLentgh + i);
var tail = tailsOrderedByLength.FirstOrDefault(t => next.EndsWith(t));
//TODO: ...
}
return(null); //FIXME
}
internal override void SetCorrespondingSide(Node <A, S> node, StackSymbolSequenceSet <S> modifiedSite, StackSymbolSequenceSet <S> otherSide)
{
node.LeftHand = modifiedSite;
node.RightHand = otherSide;
}
internal abstract void SetCorrespondingSide(Node <A, S> node, StackSymbolSequenceSet <S> modifiedSite, StackSymbolSequenceSet <S> otherSide);
public Node(StackSymbolSequenceSet <S> leftHand, StackSymbolSequenceSet <S> rightHand, Operation <A, S> operationToHere, Node <A, S> parent, DeterminisedSDA <A, S> sda, IEnumerable <A> symbols)
: this(operationToHere, parent, sda, symbols)
{
LeftHand = leftHand;
RightHand = rightHand;
}
private bool CheckBALSideCondition2(List <StackSymbolSequenceSet <S> > ownHeads, StackSymbolSequenceSet <S> premiseHeads, IEnumerable <Node <A, S> > branch)
{
var premiseHeadsAndOwnHeads = premiseHeads.StackSequenceSet.Zip(ownHeads, (stackSymbol, ownHead) => new { stackSymbol, ownHead });
var premiseHeadsWhereOwnHeadNotEmptySet = premiseHeadsAndOwnHeads.Where(t => !t.ownHead.IsEmptySet()).Select(t => t.stackSymbol).ToList();
var maxPremiseHeadNorm = premiseHeadsWhereOwnHeadNotEmptySet.Max(x =>
{
Assertion.Assert(x.StackSequence.Count() == 1, "the premise heads have to have length one");
return(sda.ShortestWordsOfStackSymbols[x.StackSequence.First()].Count());
});
return(branch.Count() == maxPremiseHeadNorm);
}
private bool CheckBALSideCondition1(List <StackSymbolSequenceSet <S> > ownHeads, StackSymbolSequenceSet <S> premiseTail)
{
var ownHeadsAreNotEmpty = ownHeads.All(h => !h.IsEpsilonSet());
if (!ownHeadsAreNotEmpty)
{
return(false);
}
var atLeastOneTailIsNotEmpty = premiseTail.StackSequenceSet.Any(s => !s.IsEpsilon());
return(atLeastOneTailIsNotEmpty);
}
public bool Equals(StackSymbolSequenceSet <S> other)
{
//FIXME: either use HashSet or order StackSequenceSet before SequenceEqual
//FIXME: HashSet has probably better performance than ordering
return(StackSequenceSet.OrderBy(s => s.Id).SequenceEqual(other.StackSequenceSet.OrderBy(s => s.Id)));
}
public StackSymbolSequenceSet <S> Multiply(StackSymbolSequenceSet <S> stackSequenceSet)
{
var res = stackSequenceSet.StackSequenceSet.SelectMany(s => Multiply(s).StackSequenceSet).ToList();
return(new StackSymbolSequenceSet <S>(res));
}
public HeadTailForm(StackSymbolSequenceSet <S> head, StackSymbolSequenceSet <S> tail)
{
Head = head;
Tail = tail;
}
