internal static FragmentQueryProcessor Merge(FragmentQueryProcessor qp1, FragmentQueryProcessor qp2)
{
var mergedKB = new FragmentQueryKBChaseSupport();
mergedKB.AddKnowledgeBase(qp1.KnowledgeBase);
mergedKB.AddKnowledgeBase(qp2.KnowledgeBase);
return(new FragmentQueryProcessor(mergedKB));
}
internal static FragmentQueryProcessor Merge(
FragmentQueryProcessor qp1,
FragmentQueryProcessor qp2)
{
FragmentQueryKBChaseSupport kb = new FragmentQueryKBChaseSupport();
kb.AddKnowledgeBase((System.Data.Entity.Core.Common.Utils.Boolean.KnowledgeBase <DomainConstraint <BoolLiteral, Constant> >)qp1.KnowledgeBase);
kb.AddKnowledgeBase((System.Data.Entity.Core.Common.Utils.Boolean.KnowledgeBase <DomainConstraint <BoolLiteral, Constant> >)qp2.KnowledgeBase);
return(new FragmentQueryProcessor(kb));
}
private void CacheNormalizedImplication(
TermExpr <DomainConstraint <BoolLiteral, Constant> > condition,
BoolExpr <DomainConstraint <BoolLiteral, Constant> > implies)
{
foreach (TermExpr <DomainConstraint <BoolLiteral, Constant> > key in this.Implications.Keys)
{
if (key.Identifier.Variable.Equals((object)condition.Identifier.Variable) && !key.Identifier.Range.SetEquals(condition.Identifier.Range))
{
this.CacheResidualFact((BoolExpr <DomainConstraint <BoolLiteral, Constant> >) new OrExpr <DomainConstraint <BoolLiteral, Constant> >(new BoolExpr <DomainConstraint <BoolLiteral, Constant> >[2]
{
(BoolExpr <DomainConstraint <BoolLiteral, Constant> >) new NotExpr <DomainConstraint <BoolLiteral, Constant> >((BoolExpr <DomainConstraint <BoolLiteral, Constant> >)condition),
implies
}));
return;
}
}
BoolExpr <DomainConstraint <BoolLiteral, Constant> > expr1 = new Converter <DomainConstraint <BoolLiteral, Constant> >(this.Chase(implies), IdentifierService <DomainConstraint <BoolLiteral, Constant> > .Instance.CreateConversionContext()).Dnf.Expr;
FragmentQueryKBChaseSupport queryKbChaseSupport = new FragmentQueryKBChaseSupport();
queryKbChaseSupport.Implications[condition] = expr1;
bool flag = true;
foreach (TermExpr <DomainConstraint <BoolLiteral, Constant> > index in new Set <TermExpr <DomainConstraint <BoolLiteral, Constant> > >((IEnumerable <TermExpr <DomainConstraint <BoolLiteral, Constant> > >) this.Implications.Keys))
{
BoolExpr <DomainConstraint <BoolLiteral, Constant> > expr2 = queryKbChaseSupport.Chase(this.Implications[index]);
if (index.Equals(condition))
{
flag = false;
expr2 = (BoolExpr <DomainConstraint <BoolLiteral, Constant> >) new AndExpr <DomainConstraint <BoolLiteral, Constant> >(new BoolExpr <DomainConstraint <BoolLiteral, Constant> >[2]
{
expr2,
expr1
});
}
this.Implications[index] = new Converter <DomainConstraint <BoolLiteral, Constant> >(expr2, IdentifierService <DomainConstraint <BoolLiteral, Constant> > .Instance.CreateConversionContext()).Dnf.Expr;
}
if (flag)
{
this.Implications[condition] = expr1;
}
this._residueSize = -1;
}
internal NonNegatedDomainConstraintTreeVisitor(FragmentQueryKBChaseSupport kb)
{
this._kb = kb;
}
internal AtomicConditionRuleChase(FragmentQueryKBChaseSupport kb)
{
this._visitor = new FragmentQueryKBChaseSupport.AtomicConditionRuleChase.NonNegatedDomainConstraintTreeVisitor(kb);
}
public FragmentQueryProcessor(FragmentQueryKBChaseSupport kb)
{
_kb = kb;
}
// Requires condition to be atomic
private void CacheNormalizedImplication(
DomainTermExpr condition, DomainBoolExpr implies)
{
// Check that we do not have a rule with an inconsistent condition yet
// such rules cannot be accommodated: we require rule premises to be pair wise
// variable disjoint (note that the rules with coinciding conditions are merged)
// rules with inconsistent conditions may make the chase incomplete:
// For instance, consider the KB {c->a, b->c, !b->a} and the condition "!a".
// chase(!a, KB) = !a, but !a ^ KB is unsatisfiable.
foreach (var premise in Implications.Keys)
{
if (premise.Identifier.Variable.Equals(condition.Identifier.Variable)
&&
!premise.Identifier.Range.SetEquals(condition.Identifier.Range))
{
CacheResidualFact(new OrExpr <DomainConstraint>(new NotExpr <DomainConstraint>(condition), implies));
return;
}
}
// We first chase the implication with all the existing facts, and then
// chase implications of all existing rules, and all residual facts with the
// resulting enhanced rule
var dnfImpl = new Converter <DomainConstraint>(
Chase(implies),
IdentifierService <DomainConstraint> .Instance.CreateConversionContext()).Dnf.Expr;
// Now chase all our knowledge with the rule "condition => dnfImpl"
// Construct a fake knowledge base for this sake
var kb = new FragmentQueryKBChaseSupport();
kb.Implications[condition] = dnfImpl;
var newKey = true;
foreach (var key in new Set <TermExpr <DomainConstraint> >(Implications.Keys))
{
var chasedRuleImpl = kb.Chase(Implications[key]);
if (key.Equals(condition))
{
newKey = false;
chasedRuleImpl = new AndExpr <DomainConstraint>(chasedRuleImpl, dnfImpl);
}
// Simplify using the solver
Implications[key] = new Converter <DomainConstraint>(
chasedRuleImpl,
IdentifierService <DomainConstraint> .Instance.CreateConversionContext()).Dnf.Expr;
}
if (newKey)
{
Implications[condition] = dnfImpl;
}
// Invalidate residue
_residueSize = -1;
}