public HashSet<GeneratorNode> spawn(FOForAll op)
{
HashSet<GeneratorNode> spawnedSet, outSet = new HashSet<GeneratorNode>();
Atom x = op.getQuantifiedVariable();
string qualifier = op.getQualifier();
// Iterate over domain
HashSet<Constant> oplus_domain = getOPlusDomain(qualifier);
HashSet<Constant> domain = op.getDomain();
SubsetIterator<Constant> it;
if (!m_encounteredQualifiers.Contains(qualifier))
{
// We haven't decomposed a For All in the past, so we can
// add elements to the message
it = new SubsetIterator<Constant>(domain, oplus_domain);
}
else
{
// Otherwise, we stick to the elements we already have to
// evaluate this quantifier
it = new SubsetIterator<Constant>(oplus_domain);
}
m_encounteredQualifiers.Add(op.getQualifier());
m_decomposedAForAll = true;
if (op.isPathNegation())
{
// The quantifier asserts the absence of a path
GeneratorNode wn = new GeneratorNode(this);
OPlus opl = new OPlus();
opl.setQualifier(op.getQualifier());
opl.setOperand(Operator.m_falseAtom);
if (!wn.addToOPluses(opl))
{
// We can't add this OPlus to the current set. Contradiction! Return the empty set
return new HashSet<GeneratorNode>();
}
return wn.spawn();
}
if (op.isPathAssertion())
{
// In negated form, the quantifier may assert the existence of a path
GeneratorNode wn = new GeneratorNode(this);
OPlus opl = new OPlus();
opl.setQualifier(op.getQualifier());
opl.setOperand(Operator.m_trueAtom);
if (!wn.addToOPluses(opl))
{
// We can't add this OPlus to the current set. Contradiction! Return the empty set
return new HashSet<GeneratorNode>();
}
return wn.spawn();
}
while (it.hasNext())
{
GeneratorNode wn = new GeneratorNode(this);
HashSet<Constant> subset = it.next();
foreach (Atom v in subset)
{
Operator o2 = op.getOperand();
Operator o3 = o2.evaluate(x, v);
OPlus opl = new OPlus(qualifier, v);
wn.addToGamma(o3);
if (!wn.addToOPluses(opl))
{
// Contradiction! Skip that branch
continue;
}
}
spawnedSet = wn.spawn();
if (spawnedSet != null)
{
foreach (GeneratorNode gn in spawnedSet)
{
outSet.Add(gn);
}
}
}
return outSet;
}
