private CompoundFormula AddKnowledgePredicatesToFormula(Formula f, HashSet <Predicate> lKnowPredicates)
{
CompoundFormula cf = new CompoundFormula("and");
HashSet <Predicate> lPredicates = new HashSet <Predicate>();
f.GetAllPredicates(lPredicates);
foreach (Predicate p in lPredicates)
{
if (lKnowPredicates.Contains(p))
{
KnowPredicate kp = new KnowPredicate(p);
cf.AddOperand(new PredicateFormula(kp));
}
}
if (f is CompoundFormula && ((CompoundFormula)f).Operator == "and")
{
foreach (Formula fSub in ((CompoundFormula)f).Operands)
{
cf.AddOperand(fSub);
}
}
else
{
cf.AddOperand(f);
}
return(cf);
}
private void AddReasoningAction(HashSet <Predicate> lPreconditions, HashSet <Predicate> lEffects, Dictionary <List <Predicate>, List <Predicate> > dActions)
{
List <Predicate> lKnowPreconditions = new List <Predicate>();
foreach (GroundedPredicate p in lPreconditions)
{
KnowPredicate pKnow = new KnowPredicate(p);
lKnowPreconditions.Add(pKnow);
lKnowPreconditions.Add(p);
}
List <Predicate> lKnowEffects = new List <Predicate>();
foreach (GroundedPredicate p in lEffects)
{
KnowPredicate pKnow = new KnowPredicate(p);
lKnowEffects.Add(pKnow);
}
if (dActions.ContainsKey(lKnowPreconditions))
{
if (dActions.Comparer.Equals(lKnowEffects, dActions[lKnowPreconditions]))
{
return;
}
throw new NotImplementedException();
}
dActions[lKnowPreconditions] = lKnowEffects;
}
private Action CreateReasoningAction(Predicate pEffect, HashSet <Predicate> lPredicates)
{
KnowPredicate kpEffect = new KnowPredicate(pEffect);
if (Predicates.Contains(kpEffect))
{
return(null);
}
Action a = new KnowledgeAction("Reasoning_" + pEffect.ToString());
a.Preconditions = new CompoundFormula("and");
foreach (Predicate pOther in lPredicates)
{
if (pOther != pEffect)
{
KnowPredicate kp = new KnowPredicate(pOther);
if (!Predicates.Contains(kp))
{
return(null);
}
((CompoundFormula)a.Preconditions).AddOperand(new PredicateFormula(kp));
}
}
CompoundFormula cfEffects = new CompoundFormula("and");
cfEffects.AddOperand(new PredicateFormula(kpEffect));
a.SetEffects(cfEffects);
return(a);
}
public KnowPredicate(KnowPredicate kp)
: base(kp.Name)
{
Knowledge = kp.Knowledge;
Value = kp.Value;
Parametrized = kp.Parametrized;
}
public override Predicate Negate()
{
/*
* KnowPredicate kpNegate = new KnowPredicate(Knowledge, Value, Parametrized);
* kpNegate.Negation = !Negation;
* return kpNegate;
*/
KnowPredicate kpNegate = new KnowPredicate(this);
kpNegate.Negation = !Negation;
return(kpNegate);
}
public override bool Equals(object obj)
{
if (obj is KnowPredicate)
{
KnowPredicate kp = (KnowPredicate)obj;
if (Value == kp.Value && Negation == kp.Negation)
{
return(Knowledge.Equals(kp.Knowledge));
}
}
return(false);
}
public override Predicate ToTag()
{
KnowPredicate ppNew = new KnowPredicate(this);
if (Negation)
{
ppNew.Name = ppNew.Name + "-Remove";
}
else
{
ppNew.Name = ppNew.Name + "-Add";
}
ppNew.Negation = false;
return(ppNew);
}
private void WriteResoningAction(StreamWriter sw, List <Predicate> lPreconditions, List <Predicate> lEffects, int iNumber)
{
sw.WriteLine("(:action R" + iNumber);
sw.Write(":precondition (and");
foreach (Predicate pPrecondition in lPreconditions)
{
if (pPrecondition is GroundedPredicate)
{
if (pPrecondition.Negation)
{
sw.Write(" (not");
}
sw.Write(" (" + pPrecondition.Name);
foreach (Constant c in ((GroundedPredicate)pPrecondition).Constants)
{
sw.Write(" " + c.Name);
}
sw.Write(")");
if (pPrecondition.Negation)
{
sw.Write(")");
}
}
else if (pPrecondition is KnowPredicate)
{
KnowPredicate kp = (KnowPredicate)pPrecondition;
sw.Write(" (K" + kp.Knowledge.Name);
foreach (Constant c in ((GroundedPredicate)kp.Knowledge).Constants)
{
sw.Write(" " + c.Name);
}
sw.Write(")");
}
}
sw.WriteLine(")");
sw.Write(":effect (and");
foreach (KnowPredicate pEffect in lEffects)
{
sw.Write(" (K" + pEffect.Knowledge.Name);
foreach (Constant c in ((GroundedPredicate)pEffect.Knowledge).Constants)
{
sw.Write(" " + c.Name);
}
sw.Write(")");
}
sw.WriteLine(")");
sw.WriteLine(")");
}
public override Formula Ground(Dictionary <string, Constant> dBindings)
{
if (Predicate is ParametrizedPredicate)
{
ParametrizedPredicate ppred = (ParametrizedPredicate)Predicate;
GroundedPredicate gpred = ppred.Ground(dBindings);
return(new PredicateFormula(gpred));
}
if (Predicate is KnowPredicate)
{
KnowPredicate kp = (KnowPredicate)Predicate;
GroundedPredicate gpred = kp.Ground(dBindings);
return(new PredicateFormula(gpred));
}
if (Predicate is KnowGivenPredicate)
{
throw new NotImplementedException();
}
return(this);
}
public override Predicate Negate()
{
/*
KnowPredicate kpNegate = new KnowPredicate(Knowledge, Value, Parametrized);
kpNegate.Negation = !Negation;
return kpNegate;
*/
KnowPredicate kpNegate = new KnowPredicate(this);
kpNegate.Negation = !Negation;
return kpNegate;
}
public KnowPredicate(KnowPredicate kp) : base(kp.Name)
{
Knowledge = kp.Knowledge;
Value = kp.Value;
Parametrized = kp.Parametrized;
}
public List<Action> KnowCompilationSplitConditions(Dictionary<string, List<Predicate>> dTags, List<string> lAlwaysKnown, List<Predicate> lAdditionalPredicates)
{
List<Action> lActions = new List<Action>();
ParametrizedAction aNewAdd = new ParametrizedAction(Name + "-Add");
ParametrizedAction aNewRemove = new ParametrizedAction(Name + "-Remove");
ParametrizedAction aNewTranslateAdd = new ParametrizedAction(Name + "-TranslateAdd");
ParametrizedAction aNewTranslateRemove = new ParametrizedAction(Name + "-TranslateRemove");
ParametrizedPredicate ppInFirst = new ParametrizedPredicate("P1-" + Name);
ParametrizedPredicate ppInSecond = new ParametrizedPredicate("P2-" + Name);
ParametrizedPredicate ppInThird = new ParametrizedPredicate("P3-" + Name);
GroundedPredicate gpNotInAction = new GroundedPredicate("NotInAction");
if (this is ParametrizedAction)
{
foreach (Parameter p in ((ParametrizedAction)this).Parameters)
{
aNewAdd.AddParameter(p);
aNewRemove.AddParameter(p);
aNewTranslateAdd.AddParameter(p);
aNewTranslateRemove.AddParameter(p);
ppInFirst.AddParameter(p);
ppInSecond.AddParameter(p);
ppInThird.AddParameter(p);
}
}
List<CompoundFormula> lConditions = new List<CompoundFormula>();
List<Formula> lObligatory = new List<Formula>();
SplitEffects(lConditions, lObligatory);
CompoundFormula cfPreconditions = new CompoundFormula("and");
HashSet<Predicate> lKnowPreconditions = new HashSet<Predicate>();
if (Preconditions != null)
{
Preconditions.GetAllPredicates(lKnowPreconditions);
cfPreconditions.AddOperand(Preconditions);
foreach (Predicate p in lKnowPreconditions)
if (!lAlwaysKnown.Contains(p.Name))
cfPreconditions.AddOperand(new PredicateFormula(new KnowPredicate(p)));
}
cfPreconditions.AddOperand(gpNotInAction);
if (Effects == null)
throw new NotImplementedException();
HashSet<Predicate> lKnowEffects = new HashSet<Predicate>();
CompoundFormula cfAddEffects = new CompoundFormula("and");
CompoundFormula cfRemoveEffects = new CompoundFormula("and");
CompoundFormula cfTranslateAddEffects = new CompoundFormula("and");
CompoundFormula cfTranslateRemoveEffects = new CompoundFormula("and");
List<Predicate> lRequireTranslation = new List<Predicate>();
foreach (Formula f in lObligatory)
{
f.GetAllPredicates(lKnowEffects);
cfAddEffects.AddOperand(f); //unconditional effects cannot conflict anyhow
}
foreach (Predicate p in lKnowEffects)
{
if (!lAlwaysKnown.Contains(p.Name))
{
Predicate pKEffect = new KnowPredicate(p);
cfAddEffects.AddOperand(pKEffect);
pKEffect = new KnowPredicate(p.Negate());
cfRemoveEffects.AddOperand(pKEffect.Negate());
foreach (string sTag in dTags.Keys)
{
pKEffect = p.GenerateKnowGiven(sTag);
cfAddEffects.AddOperand(pKEffect);
pKEffect = p.Negate().GenerateKnowGiven(sTag);
cfRemoveEffects.AddOperand(pKEffect.Negate());
}
}
}
if (lConditions.Count > 0)
{
lAdditionalPredicates.Add(ppInFirst);
lAdditionalPredicates.Add(ppInSecond);
lAdditionalPredicates.Add(ppInThird);
aNewRemove.Preconditions = cfPreconditions;
cfRemoveEffects.AddOperand(ppInFirst);
cfRemoveEffects.AddOperand(gpNotInAction.Negate());
aNewAdd.Preconditions = new PredicateFormula(ppInFirst);
cfAddEffects.AddOperand(ppInSecond);
cfAddEffects.AddOperand(ppInFirst.Negate());
aNewTranslateRemove.Preconditions = new PredicateFormula(ppInSecond);
cfTranslateRemoveEffects.AddOperand(ppInSecond.Negate());
cfTranslateRemoveEffects.AddOperand(ppInThird);
aNewTranslateAdd.Preconditions = new PredicateFormula(ppInThird);
cfTranslateAddEffects.AddOperand(ppInThird.Negate());
cfTranslateAddEffects.AddOperand(gpNotInAction);
Dictionary<Predicate, Predicate> dTaggedPredicates = new Dictionary<Predicate,Predicate>();
foreach (CompoundFormula cfCondition in lConditions)
{
CompoundFormula cfAddCondition, cfRemoveCondition;
cfCondition.SplitAddRemove(dTaggedPredicates, out cfAddCondition, out cfRemoveCondition);
if (cfAddCondition != null)
cfAddEffects.AddOperand(cfAddCondition);
if (cfRemoveCondition != null)
cfRemoveEffects.AddOperand(cfRemoveCondition);
CompoundFormula cfK = CreateKnowledgeGainCondition(cfCondition, lAlwaysKnown, false);
if (cfK != null)
{
cfK.SplitAddRemove(dTaggedPredicates, out cfAddCondition, out cfRemoveCondition);
if (cfAddCondition != null)
cfAddEffects.AddOperand(cfAddCondition);
if (cfRemoveCondition != null)
cfRemoveEffects.AddOperand(cfRemoveCondition);
}
cfK = CreateKnowledgeLossCondition(cfCondition, lAlwaysKnown);
if (cfK != null)
{
cfK.SplitAddRemove(dTaggedPredicates, out cfAddCondition, out cfRemoveCondition);
if (cfAddCondition != null)
cfAddEffects.AddOperand(cfAddCondition);
if (cfRemoveCondition != null)
cfRemoveEffects.AddOperand(cfRemoveCondition);
}
foreach (string sTag in dTags.Keys)
{
cfK = CreateTaggedKnowledgeGainCondition(cfCondition, sTag, lAlwaysKnown, false);
if (cfK != null)
{
cfK.SplitAddRemove(dTaggedPredicates, out cfAddCondition, out cfRemoveCondition);
if (cfAddCondition != null)
cfAddEffects.AddOperand(cfAddCondition);
if (cfRemoveCondition != null)
cfRemoveEffects.AddOperand(cfRemoveCondition);
}
cfK = CreateTaggedKnowledgeLossCondition(cfCondition, sTag, lAlwaysKnown);
if (cfK != null)
{
cfK.SplitAddRemove(dTaggedPredicates, out cfAddCondition, out cfRemoveCondition);
if (cfAddCondition != null)
cfAddEffects.AddOperand(cfAddCondition);
if (cfRemoveCondition != null)
cfRemoveEffects.AddOperand(cfRemoveCondition);
}
}
}
aNewAdd.Effects = cfAddEffects.Simplify();
aNewRemove.Effects = cfRemoveEffects.Simplify();
lActions.Add(aNewRemove);
lActions.Add(aNewAdd);
foreach (KeyValuePair<Predicate, Predicate> pair in dTaggedPredicates)
{
CompoundFormula cfWhen = new CompoundFormula("when");
CompoundFormula cfAnd = new CompoundFormula("and");
cfWhen.AddOperand(pair.Key);
cfAnd.SimpleAddOperand(pair.Value);
cfAnd.SimpleAddOperand(pair.Key.Negate());
cfWhen.SimpleAddOperand(cfAnd);
if (pair.Value.Negation)
cfTranslateRemoveEffects.AddOperand(cfWhen);
else
cfTranslateAddEffects.AddOperand(cfWhen);
}
aNewTranslateAdd.Effects = cfTranslateAddEffects;
aNewTranslateRemove.Effects = cfTranslateRemoveEffects;
lActions.Add(aNewTranslateRemove);
lActions.Add(aNewTranslateAdd);
}
else
{
Action aK = AddTaggedConditions(dTags, lAlwaysKnown);
lActions.Add(aK);
}
if (Observe != null)
{
throw new NotImplementedException();
}
return lActions;
}
public Action AddTaggedConditions(Dictionary<string, List<Predicate>> dTags, List<string> lAlwaysKnown)
{
Action aNew = Clone();
List<CompoundFormula> lConditions = new List<CompoundFormula>();
List<Formula> lObligatory = new List<Formula>();
SplitEffects(lConditions, lObligatory);
CompoundFormula cfPreconditions = new CompoundFormula("and");
HashSet<Predicate> lKnowPreconditions = new HashSet<Predicate>();
if (Preconditions != null)
{
Preconditions.GetAllPredicates(lKnowPreconditions);
cfPreconditions.AddOperand(Preconditions);
foreach (Predicate p in lKnowPreconditions)
if (!lAlwaysKnown.Contains(p.Name))
cfPreconditions.AddOperand(new PredicateFormula(new KnowPredicate(p)));
if (SDRPlanner.SplitConditionalEffects)
cfPreconditions.AddOperand(new GroundedPredicate("NotInAction"));
aNew.Preconditions = cfPreconditions;
}
if (Effects != null)
{
HashSet<Predicate> lKnowEffects = new HashSet<Predicate>();
CompoundFormula cfEffects = new CompoundFormula("and");
foreach (Formula f in lObligatory)
{
f.GetAllPredicates(lKnowEffects);
cfEffects.AddOperand(f);
}
foreach (Predicate p in lKnowEffects)
{
if (!lAlwaysKnown.Contains(p.Name))
{
Predicate pKEffect = new KnowPredicate(p);
cfEffects.AddOperand(pKEffect);
pKEffect = new KnowPredicate(p.Negate());
cfEffects.AddOperand(pKEffect.Negate());
foreach (string sTag in dTags.Keys)
{
pKEffect = p.GenerateKnowGiven(sTag);
cfEffects.AddOperand(pKEffect);
pKEffect = p.Negate().GenerateKnowGiven(sTag);
cfEffects.AddOperand(pKEffect.Negate());
}
}
}
foreach (CompoundFormula cfCondition in lConditions)
{
cfEffects.AddOperand(cfCondition);
CompoundFormula cfK = CreateKnowledgeGainCondition(cfCondition, lAlwaysKnown, false);
if (cfK != null)
cfEffects.AddOperand(cfK);
cfK = CreateKnowledgeLossCondition(cfCondition, lAlwaysKnown);
if (cfK != null)
cfEffects.AddOperand(cfK);
foreach (string sTag in dTags.Keys)
{
cfK = CreateTaggedKnowledgeGainCondition(cfCondition, sTag, lAlwaysKnown, false);
if (cfK != null)
cfEffects.AddOperand(cfK);
cfK = CreateTaggedKnowledgeLossCondition(cfCondition, sTag, lAlwaysKnown);
if (cfK != null)
cfEffects.AddOperand(cfK);
}
}
aNew.Effects = cfEffects;
}
if (Observe != null)
{
if (aNew.Effects == null)
aNew.Effects = new CompoundFormula("and");
Predicate pObserve = ((PredicateFormula)Observe).Predicate;
CompoundFormula cfWhen = new CompoundFormula("when");
cfWhen.AddOperand(pObserve);
cfWhen.AddOperand(new KnowPredicate(pObserve));
((CompoundFormula)aNew.Effects).AddOperand(cfWhen);
cfWhen = new CompoundFormula("when");
cfWhen.AddOperand(pObserve.Negate());
cfWhen.AddOperand(new KnowPredicate(pObserve.Negate()));
((CompoundFormula)aNew.Effects).AddOperand(cfWhen);
}
return aNew;
}
public Action KnowWhetherCompilation(Dictionary<string, List<Predicate>> dTags, Domain d)
{
Action aNew = Clone();
aNew.Name = Name + "-KW";
List<CompoundFormula> lConditions = new List<CompoundFormula>();
List<Formula> lObligatory = new List<Formula>();
SplitEffects(lConditions, lObligatory);
CompoundFormula cfKWPreconditions = new CompoundFormula("and");
HashSet<Predicate> lKnowPreconditions = new HashSet<Predicate>();
if (Preconditions != null)
{
Preconditions.GetAllPredicates(lKnowPreconditions);
foreach (Predicate p in lKnowPreconditions)
{
if(!d.AlwaysKnown(p))
cfKWPreconditions.AddOperand(new KnowWhetherPredicate(p));
if(d.AlwaysKnown(p) && d.AlwaysConstant(p))
cfKWPreconditions.AddOperand(new KnowPredicate(p));
}
if (cfKWPreconditions.Operands.Count > 0)
aNew.Preconditions = cfKWPreconditions;
else
aNew.Preconditions = null;
}
if (Effects != null)
{
HashSet<Predicate> lKnowEffects = new HashSet<Predicate>();
CompoundFormula cfEffects = new CompoundFormula("and");
CompoundFormula cfMandatoryEffects = new CompoundFormula("and");
foreach (Formula f in lObligatory)
{
f.GetAllPredicates(lKnowEffects);
//cfEffects.AddOperand(f);//BGUBGU - probably a bug here. Need to separate always known and the rest.
}
if (lKnowEffects.Count > 0)
{
foreach (string sTag in dTags.Keys)
{
//K(preconditions|s)->K(effects|s)
CompoundFormula cfKEffects = new CompoundFormula("and");
CompoundFormula cfKPreconditions = new CompoundFormula("and");
foreach (Predicate p in lKnowPreconditions)
{
if (d.AlwaysKnown(p) && d.AlwaysConstant(p))
continue;
else
cfKPreconditions.AddOperand(p.GenerateGiven(sTag));
}
foreach (Predicate p in lKnowEffects)
{
Predicate pAdd = p.GenerateGiven(sTag);
cfKEffects.AddOperand(pAdd);
//Predicate pDelete = p.Negate().GenerateKnowGiven(sTag).Negate();
//cfKEffects.AddOperand(pDelete);
}
if (cfKPreconditions.Operands.Count > 0)
{
CompoundFormula cfCondition = new CompoundFormula("when");
cfCondition.AddOperand(cfKPreconditions);
cfCondition.AddOperand(cfKEffects);
cfEffects.AddOperand(cfCondition);
}
else
cfEffects.AddOperand(cfKEffects);
}
}
//forgetting: ~K~p
foreach (Predicate p in lKnowEffects)
{
Predicate pKNotp = new KnowPredicate(p.Negate());
cfEffects.AddOperand(pKNotp.Negate());
}
foreach (CompoundFormula cfCondition in lConditions)
{
CompoundFormula cfK = null, cfOr = null, cfAnd = null;
//cfK = CreateKnowledgeGainCondition(cfCondition, d.m_lAlwaysKnown, false);
//if (cfK != null)
// cfEffects.AddOperand(cfK);
cfK = CreateKnowledgeLossCondition(cfCondition, d.m_lAlwaysKnown, false);
if (cfK != null)
{
cfOr = new CompoundFormula("or");
foreach (Predicate p in lKnowPreconditions)
{
Predicate pKNot = new KnowPredicate(p.Negate());
cfOr.AddOperand(pKNot.Negate());
}
if (cfK.Operator == "when")
{
if (cfK.Operands[0] is CompoundFormula && ((CompoundFormula)cfK.Operands[0]).Operands.Count > 0)
cfOr.AddOperand(cfK.Operands[0]);
cfK.Operands[0] = cfOr.Simplify();
}
else
{
CompoundFormula cfWhen = new CompoundFormula("when");
cfWhen.AddOperand(cfOr.Simplify());
cfWhen.AddOperand(cfK);
cfK = cfWhen;
}
cfEffects.AddOperand(cfK);
}
//cfK = CreateKnowledgeGainCondition(cfCondition, d.m_lAlwaysKnown, true);
//if (cfK != null)
// cfEffects.AddOperand(cfK);
cfK = CreateKnowledgeLossCondition(cfCondition, d.m_lAlwaysKnown, true);
if (cfK != null)
{
cfOr = new CompoundFormula("or");
foreach (Predicate p in lKnowPreconditions)
{
Predicate pKNot = new KnowPredicate(p.Negate());
cfOr.AddOperand(pKNot.Negate());
}
if (cfK.Operator == "when")
{
if (cfK.Operands[0] is PredicateFormula || ((CompoundFormula)cfK.Operands[0]).Operands.Count > 0)
cfOr.AddOperand(cfK.Operands[0]);
cfK.Operands[0] = cfOr.Simplify();
}
else
{
CompoundFormula cfWhen = new CompoundFormula("when");
cfWhen.AddOperand(cfOr.Simplify());
cfWhen.AddOperand(cfK);
cfK = cfWhen;
}
cfEffects.AddOperand(cfK);
}
foreach (string sTag in dTags.Keys)
{
cfK = CreateTaggedCondition(cfCondition, d, sTag);
if (cfK != null)
{
cfAnd = new CompoundFormula("and");
foreach (Predicate p in lKnowPreconditions)
{
if (d.AlwaysKnown(p) && d.AlwaysConstant(p))
cfAnd.AddOperand(new KnowPredicate(p));
else
cfAnd.AddOperand(p.GenerateGiven(sTag));
}
if (cfK.Operator == "when")
{
cfAnd.AddOperand(cfK.Operands[0]);
cfK.Operands[0] = cfAnd;
cfEffects.AddOperand(cfK);
}
else
throw new NotImplementedException();
}
cfK = CreateTaggedKnowledgeWhetherGainCondition(cfCondition, d, sTag);
if (cfK != null)
{
cfAnd = new CompoundFormula("and");
foreach (Predicate p in lKnowPreconditions)
{
if (d.AlwaysKnown(p) && d.AlwaysConstant(p))
cfAnd.AddOperand(new KnowPredicate(p));
else
cfAnd.AddOperand(p.GenerateGiven(sTag));
}
if (cfK.Operator == "when")
{
cfAnd.AddOperand(cfK.Operands[0]);
cfK.Operands[0] = cfAnd;
cfEffects.AddOperand(cfK);
}
else
throw new NotImplementedException();
}
cfK = CreateTaggedKnowledgeWhetherLossCondition(cfCondition, d, sTag);
if (cfK != null)
{
cfOr = new CompoundFormula("or");
foreach (Predicate p in lKnowPreconditions)
{
Predicate pKNot = new KnowPredicate(p.Negate());
cfOr.AddOperand(pKNot.Negate());
}
if (cfK.Operator == "when")
{
if (cfK.Operands[0] is PredicateFormula || ((CompoundFormula)cfK.Operands[0]).Operands.Count > 0)
cfOr.AddOperand(cfK.Operands[0]);
cfK.Operands[0] = cfOr.Simplify();
}
else
{
CompoundFormula cfWhen = new CompoundFormula("when");
cfWhen.AddOperand(cfOr.Simplify());
cfWhen.AddOperand(cfK);
cfK = cfWhen;
}
}
}
}
aNew.Effects = cfEffects.Simplify();
}
if (Observe != null)
{
throw new NotImplementedException();
}
return aNew;
}
//C->L ==> KWC/t->KWL/t
private CompoundFormula CreateTaggedKnowledgeWhetherGainConditions(CompoundFormula cfCondition, Domain d, List<string> lIncludedTags)
{
HashSet<Predicate> lPreconditions = new HashSet<Predicate>();
HashSet<Predicate> lEffects = new HashSet<Predicate>();
cfCondition.Operands[0].GetAllPredicates(lPreconditions);
cfCondition.Operands[1].GetAllPredicates(lEffects);
CompoundFormula cfWhen = new CompoundFormula("when");
CompoundFormula cfPreconditions = new CompoundFormula("and");
CompoundFormula cfEffects = new CompoundFormula("and");
foreach (Predicate p in lPreconditions)
{
if (p.Name == Domain.OPTION_PREDICATE)
return null;
Predicate pKGiven = null;
if (d.AlwaysKnown(p) && d.AlwaysConstant(p))
{
pKGiven = new KnowPredicate(p);
cfPreconditions.AddOperand(pKGiven);
}
}
foreach (string sKWTag in lIncludedTags)
{
CompoundFormula cfAnd = new CompoundFormula("and");
foreach (Predicate p in lPreconditions)
{
Predicate pKGiven = null;
if (d.AlwaysKnown(p) && d.AlwaysConstant(p))
{
continue;
}
else
{
if (!d.AlwaysKnown(p))
{
pKGiven = p.GenerateKnowGiven(sKWTag, true);
cfAnd.AddOperand(pKGiven);
}
pKGiven = p.GenerateGiven(sKWTag);
cfAnd.AddOperand(pKGiven);
}
}
if (cfAnd.Operands.Count > 0)
{
cfPreconditions.AddOperand(cfAnd);
}
foreach (Predicate p in lEffects)
{
Predicate pKEffect = p.GenerateKnowGiven(sKWTag, true);
cfEffects.AddOperand(pKEffect);
}
}
cfWhen.AddOperand(cfPreconditions.Simplify());
cfWhen.AddOperand(cfEffects.Simplify());
return cfWhen;
}
//C->L ==> KC/t->KL/t
private CompoundFormula CreateTaggedKnowledgeGainCondition(CompoundFormula cfCondition, string sTag, List<string> lAlwaysKnown, bool bNonDetEffect)
{
CompoundFormula cfWhen = new CompoundFormula("when");
HashSet<Predicate> lPreconditions = new HashSet<Predicate>();
HashSet<Predicate> lEffects = new HashSet<Predicate>();
cfCondition.Operands[0].GetAllPredicates(lPreconditions);
cfCondition.Operands[1].GetAllPredicates(lEffects);
Formula cfPreconditions = cfCondition.Operands[0].GenerateGiven(sTag, lAlwaysKnown);
CompoundFormula cfEffects = new CompoundFormula("and");
foreach (Predicate p in lEffects)
{
if (lAlwaysKnown == null || !lAlwaysKnown.Contains(p.Name))
{
Predicate pKEffect = p.GenerateKnowGiven(sTag);
cfEffects.AddOperand(pKEffect);
if (bNonDetEffect)
{
KnowPredicate pK = new KnowPredicate(p);
cfEffects.AddOperand(pK.Negate());
}
}
}
if (cfEffects.Operands.Count == 0)
return null;
cfWhen.AddOperand(cfPreconditions.Simplify());
cfWhen.AddOperand(cfEffects.Simplify());
return cfWhen;
}
//C->L ==> KWC/t->KWL/t
private CompoundFormula CreateTaggedKnowledgeWhetherGainConditions(CompoundFormula cfCondition, Domain d, IEnumerable<string> lTags, string sActionTag)
{
HashSet<Predicate> lPreconditions = new HashSet<Predicate>();
HashSet<Predicate> lEffects = new HashSet<Predicate>();
cfCondition.Operands[0].GetAllPredicates(lPreconditions);
cfCondition.Operands[1].GetAllPredicates(lEffects);
CompoundFormula cfAllConditions = new CompoundFormula("and");
foreach (string sKWTag in lTags)
{
CompoundFormula cfWhen = new CompoundFormula("when");
CompoundFormula cfPreconditions = new CompoundFormula("and");
CompoundFormula cfEffects = new CompoundFormula("and");
if (sKWTag != sActionTag)
{
Predicate pNotKWTag = Predicate.GenerateKNot(new Constant(Domain.TAG, sKWTag),new Constant(Domain.TAG, sActionTag));
cfPreconditions.AddOperand(pNotKWTag.Negate());
}
foreach (Predicate p in lPreconditions)
{
if (p.Name == Domain.OPTION_PREDICATE)
return null;
Predicate pKGiven = null;
if (d.AlwaysKnown(p) && d.AlwaysConstant(p))
{
pKGiven = new KnowPredicate(p);
cfPreconditions.AddOperand(pKGiven);
}
}
foreach (string sTag in lTags)
{
CompoundFormula cfAnd = new CompoundFormula("and");
foreach (Predicate p in lPreconditions)
{
Predicate pKGiven = null;
//if (d.AlwaysKnown(p) && d.AlwaysConstant(p))
if (d.AlwaysKnown(p))
{
continue;
}
else
{
/*
if (!d.AlwaysKnown(p))
{
pKGiven = p.GenerateKnowGiven(sTag, true);
cfAnd.AddOperand(pKGiven);
}
* */
pKGiven = p.GenerateGiven(sTag);
cfAnd.AddOperand(pKGiven);
}
}
if (cfAnd.Operands.Count > 0)//if there are no conditions then it is always true, and we don't need to care about whether the tag is consistent or not
{
if (sTag == sActionTag)
{
cfPreconditions.AddOperand(cfAnd);
}
else
{
CompoundFormula cfOr = new CompoundFormula("or");
Predicate pNotTag = Predicate.GenerateKNot(new Constant(Domain.TAG, sTag),new Constant(Domain.TAG, sActionTag));
cfOr.AddOperand(pNotTag);
cfOr.AddOperand(cfAnd);
cfPreconditions.AddOperand(cfOr);
}
}
}
foreach (Predicate p in lEffects)
{
//Predicate pKEffect = p.GenerateKnowGiven(sKWTag, true);
Predicate pKEffect = p.GenerateGiven(sKWTag);
cfEffects.AddOperand(pKEffect);
}
cfWhen.AddOperand(cfPreconditions.Simplify());
cfWhen.AddOperand(cfEffects.Simplify());
cfAllConditions.SimpleAddOperand(cfWhen);
}
return cfAllConditions;
}
private CompoundFormula AddKnowledgePredicatesToFormula(Formula f, HashSet<Predicate> lKnowPredicates)
{
CompoundFormula cf = new CompoundFormula("and");
HashSet<Predicate> lPredicates = new HashSet<Predicate>();
f.GetAllPredicates(lPredicates);
foreach (Predicate p in lPredicates)
{
if (lKnowPredicates.Contains(p))
{
KnowPredicate kp = new KnowPredicate(p);
cf.AddOperand(new PredicateFormula(kp));
}
}
if (f is CompoundFormula && ((CompoundFormula)f).Operator == "and")
{
foreach (Formula fSub in ((CompoundFormula)f).Operands)
cf.AddOperand(fSub);
}
else
cf.AddOperand(f);
return cf;
}
public override Predicate ToTag()
{
KnowPredicate ppNew = new KnowPredicate(this);
if (Negation)
ppNew.Name = ppNew.Name + "-Remove";
else
ppNew.Name = ppNew.Name + "-Add";
ppNew.Negation = false;
return ppNew;
}
/*
public List<Action> KnowCompilationSplitConditions(Dictionary<string, List<Predicate>> dTags, List<string> lAlwaysKnown, List<Predicate> lAdditionalPredicates)
{
List<Action> lActions = new List<Action>();
ParametrizedAction aNewState = new ParametrizedAction(Name + "-State");
ParametrizedAction aNewKnowledgeGain = new ParametrizedAction(Name + "-KnowledgeGain");
ParametrizedAction aNewKnowledgeLoss = new ParametrizedAction(Name + "-KnowledgeLoss");
ParametrizedPredicate ppInFirst = new ParametrizedPredicate("P1-" + Name);
ParametrizedPredicate ppInSecond = new ParametrizedPredicate("P2-" + Name);
GroundedPredicate gpNotInAction = new GroundedPredicate("NotInAction");
if (this is ParametrizedAction)
{
foreach (Parameter p in ((ParametrizedAction)this).Parameters)
{
aNewKnowledgeLoss.AddParameter(p);
aNewKnowledgeGain.AddParameter(p);
aNewState.AddParameter(p);
ppInFirst.AddParameter(p);
ppInSecond.AddParameter(p);
}
}
List<CompoundFormula> lConditions = new List<CompoundFormula>();
List<Formula> lObligatory = new List<Formula>();
SplitEffects(lConditions, lObligatory);
CompoundFormula cfPreconditions = new CompoundFormula("and");
List<Predicate> lKnowPreconditions = new List<Predicate>();
if (Preconditions != null)
{
Preconditions.GetAllPredicates(lKnowPreconditions);
cfPreconditions.AddOperand(Preconditions);
foreach (Predicate p in lKnowPreconditions)
if (!lAlwaysKnown.Contains(p.Name))
cfPreconditions.AddOperand(new PredicateFormula(new KnowPredicate(p)));
}
cfPreconditions.AddOperand(gpNotInAction);
aNewKnowledgeGain.Preconditions = cfPreconditions;//knowledge gain is the first action, so it will have all the preconditions
if (Effects == null)
throw new NotImplementedException();
List<Predicate> lKnowEffects = new List<Predicate>();
CompoundFormula cfStateEffects = new CompoundFormula("and");
CompoundFormula cfKnowledgeLossEffects = new CompoundFormula("and");
CompoundFormula cfKnowledgeGainEffects = new CompoundFormula("and");
foreach (Formula f in lObligatory)
{
f.GetAllPredicates(lKnowEffects);
cfStateEffects.AddOperand(f);
}
foreach (Predicate p in lKnowEffects)
{
if (!lAlwaysKnown.Contains(p.Name))
{
Predicate pKEffect = new KnowPredicate(p);
cfKnowledgeGainEffects.AddOperand(pKEffect);
pKEffect = new KnowPredicate(p.Negate());
cfKnowledgeGainEffects.AddOperand(pKEffect.Negate());
foreach (string sTag in dTags.Keys)
{
pKEffect = p.GenerateKnowGiven(sTag);
cfKnowledgeGainEffects.AddOperand(pKEffect);
pKEffect = p.Negate().GenerateKnowGiven(sTag);
cfKnowledgeGainEffects.AddOperand(pKEffect.Negate());
}
}
}
if (lConditions.Count > 0)
{
lAdditionalPredicates.Add(ppInFirst);
lAdditionalPredicates.Add(ppInSecond);
aNewKnowledgeGain.Preconditions = cfPreconditions;
aNewKnowledgeLoss.Preconditions = new PredicateFormula(ppInFirst);
aNewState.Preconditions = new PredicateFormula(ppInSecond);
cfKnowledgeGainEffects.AddOperand(ppInFirst);
cfKnowledgeGainEffects.AddOperand(gpNotInAction.Negate());
cfKnowledgeLossEffects.AddOperand(ppInSecond);
cfKnowledgeLossEffects.AddOperand(ppInFirst.Negate());
cfStateEffects.AddOperand(ppInSecond.Negate());
cfStateEffects.AddOperand(gpNotInAction);
foreach (CompoundFormula cfCondition in lConditions)
{
cfStateEffects.AddOperand(cfCondition);
CompoundFormula cfK = CreateKnowledgeGainCondition(cfCondition, lAlwaysKnown, false);
if (cfK != null)
cfKnowledgeGainEffects.AddOperand(cfK);
cfK = CreateKnowledgeLossCondition(cfCondition, lAlwaysKnown);
if (cfK != null)
cfKnowledgeLossEffects.AddOperand(cfK);
foreach (string sTag in dTags.Keys)
{
cfK = CreateTaggedKnowledgeGainCondition(cfCondition, sTag, lAlwaysKnown, false);
if (cfK != null)
cfKnowledgeGainEffects.AddOperand(cfK);
cfK = CreateTaggedKnowledgeLossCondition(cfCondition, sTag, lAlwaysKnown);
if (cfK != null)
cfKnowledgeLossEffects.AddOperand(cfK);
}
}
aNewKnowledgeGain.Effects = cfKnowledgeGainEffects.Simplify();
aNewKnowledgeLoss.Effects = cfKnowledgeLossEffects.Simplify();
lActions.Add(aNewKnowledgeLoss);
lActions.Add(aNewKnowledgeGain);
}
else
{
aNewState.Preconditions = cfPreconditions;
}
aNewState.Effects = cfStateEffects.Simplify();
lActions.Add(aNewState);
if (Observe != null)
{
throw new NotImplementedException();
}
return lActions;
}
*/
public Action KnowCompilation(Dictionary<string, List<Predicate>> dTags, Domain d)
{
Action aNew = Clone();
aNew.Name = Name + "-K";
List<CompoundFormula> lConditions = new List<CompoundFormula>();
List<Formula> lObligatory = new List<Formula>();
SplitEffects(lConditions, lObligatory);
CompoundFormula cfPreconditions = new CompoundFormula("and");
HashSet<Predicate> lKnowPreconditions = new HashSet<Predicate>();
if (Preconditions != null)
{
Preconditions.GetAllPredicates(lKnowPreconditions);
foreach (Predicate p in lKnowPreconditions)
{
cfPreconditions.AddOperand(new KnowPredicate(p));
}
aNew.Preconditions = cfPreconditions;
}
else
aNew.Preconditions = null;
if (Effects != null)
{
HashSet<Predicate> lKnowEffects = new HashSet<Predicate>();
CompoundFormula cfEffects = new CompoundFormula("and");
foreach (Formula f in lObligatory)
{
f.GetAllPredicates(lKnowEffects);
//cfEffects.AddOperand(f);//BGUBGU - probably a bug here. Need to separate always known and the rest.
}
foreach (Predicate p in lKnowEffects)
{
Predicate pKEffect = new KnowPredicate(p);
cfEffects.AddOperand(pKEffect);
Predicate pKNegateEffect = new KnowPredicate(p.Negate()).Negate();
cfEffects.AddOperand(pKNegateEffect);
/* why do we need all this?
pKEffect = new KnowPredicate(p.Negate());
cfEffects.AddOperand(pKEffect.Negate());
foreach (string sTag in dTags.Keys)
{
pKEffect = p.GenerateGiven(sTag);
cfEffects.AddOperand(pKEffect);
pKEffect = p.Negate().GenerateGiven(sTag);
cfEffects.AddOperand(pKEffect.Negate());
}
*/
}
foreach (string sTag in dTags.Keys)
{
//e|s
CompoundFormula cfKEffects = new CompoundFormula("and");
foreach (Predicate p in lKnowEffects)
{
Predicate pAdd = p.GenerateGiven(sTag);
cfKEffects.AddOperand(pAdd);
}
cfEffects.SimpleAddOperand(cfKEffects);
}
foreach (CompoundFormula cfCondition in lConditions)
{
//cfEffects.AddOperand(cfCondition);//no longer valid? Perhaps needed if there are some "always known" conditions?
CompoundFormula cfK = CreateKnowledgeGainCondition(cfCondition, d.m_lAlwaysKnown, false);
if (cfK != null)
cfEffects.AddOperand(cfK);
cfK = CreateKnowledgeLossCondition(cfCondition, d.m_lAlwaysKnown, false);
if (cfK != null)
{
if(cfK.Operator == "and" || cfK.Operands[0] is PredicateFormula ||
cfK.Operands[0] is CompoundFormula && (((CompoundFormula)cfK.Operands[0]).Operands.Count > 0))
cfEffects.SimpleAddOperand(cfK);
}
//cfK = CreateKnowledgeGainCondition(cfCondition, d.m_lAlwaysKnown, true);
//if (cfK != null)
// cfEffects.AddOperand(cfK);
cfK = CreateKnowledgeLossCondition(cfCondition, d.m_lAlwaysKnown, true);
if (cfK != null)
{
if (cfK.Operator == "and" || cfK.Operands[0] is PredicateFormula ||
cfK.Operands[0] is CompoundFormula && (((CompoundFormula)cfK.Operands[0]).Operands.Count > 0))
cfEffects.SimpleAddOperand(cfK);
}
foreach (string sTag in dTags.Keys)
{
cfK = CreateTaggedCondition(cfCondition, d, sTag);
cfEffects.AddOperand(cfK);
cfK = CreateTaggedKnowledgeWhetherGainCondition(cfCondition, d, sTag);
if (cfK != null)
{
cfEffects.SimpleAddOperand(cfK);
}
cfK = CreateTaggedKnowledgeWhetherLossCondition(cfCondition, d, sTag);
if (cfK != null)
cfEffects.SimpleAddOperand(cfK);
}
}
aNew.Effects = cfEffects.Simplify();
}
if (Observe != null)
{
throw new NotImplementedException();
}
return aNew;
}
private Action CreateReasoningAction(Predicate pEffect, HashSet<Predicate> lPredicates)
{
KnowPredicate kpEffect = new KnowPredicate(pEffect);
if (Predicates.Contains(kpEffect))
return null;
Action a = new KnowledgeAction("Reasoning_" + pEffect.ToString());
a.Preconditions = new CompoundFormula("and");
foreach (Predicate pOther in lPredicates)
{
if (pOther != pEffect)
{
KnowPredicate kp = new KnowPredicate(pOther);
if (!Predicates.Contains(kp))
return null;
((CompoundFormula)a.Preconditions).AddOperand(new PredicateFormula(kp));
}
}
CompoundFormula cfEffects = new CompoundFormula("and");
cfEffects.AddOperand(new PredicateFormula(kpEffect));
a.SetEffects(cfEffects);
return a;
}
