private Formula ReadFormula(CompoundExpression exp, Dictionary<string, string> dParameterNameToType, bool bParamterized, Domain d) { bool bPredicate = true; //Console.WriteLine(exp); if (d!= null && d.IsFunctionExpression(exp.Type)) { Predicate p = ReadFunctionExpression(exp, dParameterNameToType, d); return new PredicateFormula(p); } else if (IsUniversalQuantifier(exp)) { CompoundExpression eParameter = (CompoundExpression)exp.SubExpressions[0]; CompoundExpression eBody = (CompoundExpression)exp.SubExpressions[1]; string sParameter = eParameter.Type; string sType = eParameter.SubExpressions[1].ToString(); dParameterNameToType[sParameter] = sType; ParametrizedFormula cfQuantified = new ParametrizedFormula(exp.Type); cfQuantified.Parameters[sParameter] = sType; Formula fBody = ReadFormula(eBody, dParameterNameToType, true, d); cfQuantified.AddOperand(fBody); return cfQuantified; } else if (exp.Type == "probabilistic") { ProbabilisticFormula pf = new ProbabilisticFormula(); int iExpression = 0; for (iExpression = 0; iExpression < exp.SubExpressions.Count; iExpression+=2) { //if (exp.SubExpressions[iExpression] is StringExpression) // throw new InvalidDataException(); string sProb = exp.SubExpressions[iExpression].ToString(); double dProb = 0.0; if (sProb.Contains("/")) { string[] a = sProb.Split('/'); dProb = double.Parse(a[0]) / double.Parse(a[1]); } else { dProb = double.Parse(sProb); } Formula f = ReadFormula((CompoundExpression)exp.SubExpressions[iExpression + 1], dParameterNameToType, bParamterized, d); pf.AddOption(f, dProb); } return pf; } else { foreach (Expression eSub in exp.SubExpressions) { if (eSub is CompoundExpression) { bPredicate = false; break; } } if (bPredicate) return ReadPredicate(exp, dParameterNameToType, bParamterized, d); else { CompoundFormula cf = new CompoundFormula(exp.Type); int iExpression = 0; for (iExpression = 0; iExpression < exp.SubExpressions.Count; iExpression++) { if (exp.SubExpressions[iExpression] is StringExpression) throw new InvalidDataException(); Formula f = ReadFormula((CompoundExpression)exp.SubExpressions[iExpression], dParameterNameToType, bParamterized, d); cf.SimpleAddOperand(f); } if (cf.Operator == "not" && cf.Operands[0] is PredicateFormula) { PredicateFormula fNegate = new PredicateFormula(((PredicateFormula)cf.Operands[0]).Predicate.Negate()); return fNegate; } return cf; } } }
/* * public CompoundFormula GetPreconditionsNoState(Dictionary<string, List<Predicate>> dTags, Domain d, List<string> lIncludedTags, List<string> lExcludedTags) { CompoundFormula cfPreconditions = new CompoundFormula("and"); HashSet<Predicate> lKnowPreconditions = new HashSet<Predicate>(); if (Preconditions != null) { //foreach tag t, either KNot t | ?t, or forall precondition p, p|t Preconditions.GetAllPredicates(lKnowPreconditions); foreach (Predicate p in lKnowPreconditions) { if (d.AlwaysKnown(p) && (d.AlwaysConstant(p))) cfPreconditions.AddOperand(p); } foreach (string sTag in lIncludedTags) { CompoundFormula cfAnd = new CompoundFormula("and"); foreach (Predicate p in lKnowPreconditions) { if (d.AlwaysKnown(p) && (d.AlwaysConstant(p))) continue; else { cfAnd.AddOperand(p.GenerateGiven(sTag)); } } if (cfAnd.Operands.Count > 0) cfPreconditions.SimpleAddOperand(cfAnd.Simplify()); } } foreach (string sTag in lIncludedTags) { //this allows only actions on non-distinguishable tag sets - it is possible to allow actions that apply to distinguishable tag sets if (sTag != lIncludedTags[0]) { Predicate pKNotT = Predicate.GenerateKNot(new Constant(Domain.TAG, sTag),new Constant(Domain.TAG, lIncludedTags[0])); cfPreconditions.AddOperand(pKNotT.Negate()); } } foreach (string sTag in lExcludedTags) { Predicate pNotTag = Predicate.GenerateKNot(new Constant(Domain.TAG, sTag),new Constant(Domain.TAG, lIncludedTags[0])); cfPreconditions.AddOperand(pNotTag); } //if (cfPreconditions.Operands.Count > 0) return cfPreconditions; //return null; } */ public CompoundFormula GetKnowWhetherPreconditions(Dictionary<string, List<Predicate>> dTags, Domain d, string sActionTag) { Argument pTag = new Constant(Domain.TAG, sActionTag); CompoundFormula cfKWPreconditions = new CompoundFormula("and"); HashSet<Predicate> lKnowPreconditions = new HashSet<Predicate>(); CompoundFormula cfOr = null; if (Preconditions != null) { //foreach tag t, either KNot t | ?t, or forall precondition p, p|t Preconditions.GetAllPredicates(lKnowPreconditions); foreach (Predicate p in lKnowPreconditions) { if (d.AlwaysKnown(p) && (d.AlwaysConstant(p))) cfKWPreconditions.AddOperand(p); } foreach (string sTag in dTags.Keys) { Predicate pNotTag = Predicate.GenerateKNot(new Constant(Domain.TAG, sTag), (Constant)pTag); cfOr = new CompoundFormula("or"); CompoundFormula cfAnd = new CompoundFormula("and"); cfAnd.AddOperand(pNotTag.Negate()); foreach (Predicate p in lKnowPreconditions) { //if (d.AlwaysKnown(p) && (d.AlwaysConstant(p))) if (d.AlwaysKnown(p) && (d.AlwaysConstant(p))) continue; else { cfAnd.AddOperand(p.GenerateGiven(sTag)); //if (!d.AlwaysKnown(p)) // cfAnd.AddOperand(p.GenerateKnowGiven(sTag, true)); } } if (cfAnd.Operands.Count > 0) cfOr.AddOperand(cfAnd); if (sTag == sActionTag) { cfKWPreconditions.SimpleAddOperand(cfAnd); } else { cfOr.AddOperand(pNotTag); cfKWPreconditions.SimpleAddOperand(cfOr.Simplify()); } } } if (cfKWPreconditions.Operands.Count > 0) return cfKWPreconditions; return null; }
//this implementation requires ~Knot between all include tags, and Knot between every include and every exclude tags public CompoundFormula GetPreconditionsNoState(Dictionary<string, List<Predicate>> dTags, Domain d, List<string> lIncludedTags, List<string> lExcludedTags) { CompoundFormula cfPreconditions = new CompoundFormula("and"); if (Preconditions != null) { HashSet<Predicate> lKnowPreconditions = Preconditions.GetAllPredicates(); foreach (Predicate p in lKnowPreconditions) { if (d.AlwaysKnown(p) && (d.AlwaysConstant(p))) cfPreconditions.AddOperand(p); } foreach (string sTag in lIncludedTags) { CompoundFormula cfAnd = new CompoundFormula("and"); foreach (Predicate p in lKnowPreconditions) { if (d.AlwaysKnown(p) && (d.AlwaysConstant(p))) continue; else { cfAnd.AddOperand(p.GenerateGiven(sTag)); } } if (cfAnd.Operands.Count > 0) cfPreconditions.SimpleAddOperand(cfAnd.Simplify()); } } //this allows only actions on non-distinguishable tag sets - it is possible to allow actions that apply to distinguishable tag sets for (int iIncludeTag = 0; iIncludeTag < lIncludedTags.Count; iIncludeTag++) { for (int iOtherIncludeTag = iIncludeTag + 1; iOtherIncludeTag < lIncludedTags.Count; iOtherIncludeTag++) { Predicate pKNotT = Predicate.GenerateKNot(new Constant(Domain.TAG, lIncludedTags[iIncludeTag]), new Constant(Domain.TAG, lIncludedTags[iOtherIncludeTag])); cfPreconditions.AddOperand(pKNotT.Negate()); } } foreach (string sIncludeTag in lIncludedTags) { foreach (string sExcludeTag in lExcludedTags) { Predicate pNotTag = Predicate.GenerateKNot(new Constant(Domain.TAG, sIncludeTag), new Constant(Domain.TAG, sExcludeTag)); cfPreconditions.AddOperand(pNotTag); } } return cfPreconditions; }
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 CompoundFormula GetKnowWhetherPreconditions(Dictionary<string, List<Predicate>> dTags, Domain d, List<string> lIncludedTags, List<string> lExcludedTags) { CompoundFormula cfKWPreconditions = new CompoundFormula("and"); HashSet<Predicate> lKnowPreconditions = new HashSet<Predicate>(); if (Preconditions != null) { //foreach tag t, either KNot t | ?t, or forall precondition p, p|t Preconditions.GetAllPredicates(lKnowPreconditions); foreach (Predicate p in lKnowPreconditions) { if (d.AlwaysKnown(p) && (d.AlwaysConstant(p))) cfKWPreconditions.AddOperand(new KnowPredicate(p)); } foreach (string sTag in lIncludedTags) { CompoundFormula cfAnd = new CompoundFormula("and"); foreach (Predicate p in lKnowPreconditions) { if (d.AlwaysKnown(p) && (d.AlwaysConstant(p))) continue; else { cfAnd.AddOperand(p.GenerateGiven(sTag)); if (!d.AlwaysKnown(p)) cfAnd.AddOperand(p.GenerateKnowGiven(sTag, true)); } } if (cfAnd.Operands.Count > 0) cfKWPreconditions.SimpleAddOperand(cfAnd.Simplify()); //this allows only actions on non-distinguishable tag sets - it is possible to allow actions that apply to distinguishable tag sets if (sTag != lIncludedTags[0]) { Predicate pKNotT = Predicate.GenerateKNot(new Constant(Domain.TAG, sTag),new Constant(Domain.TAG, lIncludedTags[0])); cfKWPreconditions.AddOperand(pKNotT.Negate()); } } } foreach (string sTag in lExcludedTags) { Predicate pNotTag = Predicate.GenerateKNot(new Constant(Domain.TAG, sTag),new Constant(Domain.TAG, lIncludedTags[0])); cfKWPreconditions.AddOperand(pNotTag); } if(cfKWPreconditions.Operands.Count > 0) return cfKWPreconditions; return null; }
public override Formula Simplify() { Formula fSimplified = null; if (Simplified) return this; if( Operator == "not" ) fSimplified = Negate(); if (Operands.Count == 1) fSimplified = Operands[0].Simplify(); if (Operator == "when") { CompoundFormula cfNew = new CompoundFormula(Operator); Formula fFirst = Operands[0].Simplify(); Formula fSecond = Operands[1].Simplify(); cfNew.SimpleAddOperand(fFirst); if (IsSimpleAnd(fFirst) && IsSimpleAnd(fSecond)) { HashSet<Predicate> lFirst = fFirst.GetAllPredicates(); HashSet<Predicate> lSecond = fSecond.GetAllPredicates(); CompoundFormula cfSecond = new CompoundFormula("and"); foreach (Predicate p in lSecond) if (!lFirst.Contains(p)) cfSecond.AddOperand(p); cfNew.SimpleAddOperand(cfSecond); } else { cfNew.SimpleAddOperand(fSecond); } cfNew.Simplified = true; fSimplified = cfNew; } else if (Operator == "and" || Operator == "or" || Operator == "oneof") { /* if (Operands.Count == 0) { if (Operator == "and") return new PredicateFormula(new GroundedPredicate(Domain.TRUE_PREDICATE)); if (Operator == "or" || Operator == "oneof") return new PredicateFormula(new GroundedPredicate(Domain.FALSE_PREDICATE)); } * */ CompoundFormula cfNew = new CompoundFormula(Operator); foreach (Formula f in Operands) { Formula fSimplify = f.Simplify(); if (fSimplify is CompoundFormula) { CompoundFormula cf = (CompoundFormula)fSimplify; if (cf.Operator == Operator) { foreach (Formula ff in cf.Operands) cfNew.AddOperand(ff); } else cfNew.AddOperand(cf); } else if (fSimplify is ProbabilisticFormula) { cfNew.AddOperand(fSimplify); } else { Predicate p = ((PredicateFormula)fSimplify).Predicate; if (p.Name == Domain.TRUE_PREDICATE) { if (Operator == "or") return fSimplify; } else if (p.Name == Domain.FALSE_PREDICATE) { if (Operator == "and") return fSimplify; } else cfNew.AddOperand(fSimplify); } } if (cfNew.Operands.Count == 1) return cfNew.Operands[0]; if (cfNew.Operator == "or") cfNew = cfNew.RemoveRedundancies(); fSimplified = cfNew; } if( fSimplified is CompoundFormula ) ((CompoundFormula)fSimplified).Simplified = true; return fSimplified; }
public override Formula Clone() { CompoundFormula cfClone = new CompoundFormula(Operator); foreach (Formula f in Operands) cfClone.SimpleAddOperand(f.Clone()); return cfClone; }
public List<Action> TagCompilationSplitConditionsNoState(Dictionary<string, List<Predicate>> dTags, Domain d, List<string> lIncludedTags, List<string> lExcludedTags, List<Predicate> lAdditionalPredicates) { string sName = Name; foreach (string sTag in lIncludedTags) sName += "-" + sTag; ParametrizedAction aNew = new ParametrizedAction(sName); if (this is ParametrizedAction) { foreach (Parameter p in ((ParametrizedAction)this).Parameters) { aNew.AddParameter(p); } } List<CompoundFormula> lConditions = new List<CompoundFormula>(); List<Formula> lObligatory = new List<Formula>(); SplitEffects(lConditions, lObligatory); CompoundFormula cfPreconditions = new CompoundFormula("and"); Formula cfNoStatePreconditions = GetPreconditionsNoState(dTags, d, lIncludedTags, lExcludedTags); cfPreconditions.AddOperand(cfNoStatePreconditions); //knowledge loss is the first action, so it will have all the preconditions aNew.Preconditions = cfPreconditions; if (Effects == null) throw new NotImplementedException(); HashSet<Predicate> lKnowEffects = new HashSet<Predicate>(); CompoundFormula cfStateEffects = new CompoundFormula("and"); //CompoundFormula cfMandatoryEffects = new CompoundFormula("and"); foreach (Formula f in lObligatory) { f.GetAllPredicates(lKnowEffects); } if (lKnowEffects.Count > 0) { foreach (string sTag in lIncludedTags) { //~KNot t|?t -> effects|t CompoundFormula cfKEffects = new CompoundFormula("and"); foreach (Predicate p in lKnowEffects) { Predicate pAdd = p.GenerateGiven(sTag); cfKEffects.AddOperand(pAdd); } cfStateEffects.SimpleAddOperand(cfKEffects); } } List<Action> lActions = new List<Action>(); if (lConditions.Count > 0) { foreach (CompoundFormula cfCondition in lConditions) { CompoundFormula cfK = null, cfAnd = null; HashSet<Predicate> lConditionEffects = cfCondition.Operands[1].GetAllPredicates(); cfAnd = new CompoundFormula("and"); foreach (string sTag in lIncludedTags) { cfK = CreateTaggedCondition(cfCondition, d, sTag); if (cfK != null) { cfStateEffects.SimpleAddOperand(cfK); } } } } aNew.Effects = cfStateEffects.Simplify(); if (lConditions.Count > 0 && SDRPlanner.SplitConditionalEffects) lActions.AddRange(aNew.SplitConditions(lAdditionalPredicates)); else { ((CompoundFormula)aNew.Preconditions).AddOperand(new GroundedPredicate("NotInAction")); lActions.Add(aNew); } if (Observe != null) { throw new NotImplementedException(); } return lActions; }
public Action TagObservationTranslationNoState(Dictionary<string, List<Predicate>> dTags, Domain d, List<string> lIncludedTags, List<string> lExcludedTags) { string sName = Name; foreach (string sTag in lIncludedTags) sName += "-" + sTag; ParametrizedAction aNew = new ParametrizedAction(sName); if (this is ParametrizedAction) { foreach (Parameter p in ((ParametrizedAction)this).Parameters) aNew.AddParameter(p); } if (Observe == null) throw new NotImplementedException(); if (Effects != null) throw new NotImplementedException(); Predicate pObserve = ((PredicateFormula)Observe).Predicate; aNew.Preconditions = GetPreconditionsNoState(dTags, d, lIncludedTags, lExcludedTags); ((CompoundFormula)aNew.Preconditions).AddOperand(new GroundedPredicate("NotInAction")); CompoundFormula cfEffects = new CompoundFormula("and"); /* foreach (string sTag in lIncludedTags) { cfEffects.AddOperand(pObserve.GenerateKnowGiven(sTag, true)); } */ for (int i = 0; i < lIncludedTags.Count - 1; i++) { for (int j = i + 1; j < lIncludedTags.Count; j++) { string sTag1 = lIncludedTags[i], sTag2 = lIncludedTags[j]; CompoundFormula cfWhen = new CompoundFormula("when"); CompoundFormula cfGiven = new CompoundFormula("and"); CompoundFormula cfEffect = new CompoundFormula("and"); cfGiven.AddOperand(pObserve.GenerateGiven(sTag1)); cfGiven.AddOperand(pObserve.GenerateGiven(sTag2).Negate()); Constant pTag1 = new Constant(Domain.TAG, sTag1); Constant pTag2 = new Constant(Domain.TAG, sTag2); Predicate ppKnowNot1Given2 = Predicate.GenerateKNot(pTag1, pTag2); cfEffect.AddOperand(ppKnowNot1Given2);//no need to add the other side because all KNot will enforce t1 < t2 cfWhen.SimpleAddOperand(cfGiven); cfWhen.SimpleAddOperand(cfEffect); cfEffects.SimpleAddOperand(cfWhen); cfWhen = new CompoundFormula("when"); cfGiven = new CompoundFormula("and"); cfGiven.AddOperand(pObserve.GenerateGiven(sTag1).Negate()); cfGiven.AddOperand(pObserve.GenerateGiven(sTag2)); cfWhen.SimpleAddOperand(cfGiven); cfWhen.SimpleAddOperand(cfEffect); cfEffects.SimpleAddOperand(cfWhen); } } aNew.Effects = cfEffects; return aNew; }
public void SimplifyConditions() { Debug.WriteLine("Converting action " + Name); if (Effects != null) { CompoundFormula cfNewEffects = new CompoundFormula("and"); List<CompoundFormula> lConditions = new List<CompoundFormula>(); List<Formula> lMandatory = new List<Formula>(); SplitEffects(lConditions, lMandatory); foreach (Formula f in lMandatory) cfNewEffects.SimpleAddOperand(f); int iCondition = 0, cConditions = lConditions.Count; foreach (CompoundFormula cfCondition in lConditions) { if(cfCondition.Operands[0] is PredicateFormula) cfNewEffects.SimpleAddOperand(cfCondition); else { CompoundFormula cfNewCondition = new CompoundFormula("when"); CompoundFormula cfNewFirst = (CompoundFormula)((CompoundFormula)cfCondition.Operands[0]).ToCNF(); cfNewCondition.AddOperand(cfNewFirst); cfNewCondition.AddOperand(cfCondition.Operands[1]); cfNewEffects.SimpleAddOperand(cfNewCondition); } iCondition++; Debug.Write("\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b" + iCondition + "/" + cConditions); } Effects = cfNewEffects; } }
public List<Action> SplitConditions(List<Predicate> lAdditionalPredicates) { List<Action> lActions = new List<Action>(); ParametrizedAction aNewAdd = new ParametrizedAction(Name + "-Add"); ParametrizedAction aNewRemove = new ParametrizedAction(Name + "-Remove"); ParametrizedAction aNewTranslateRemove = new ParametrizedAction(Name + "-TranslateRemove"); ParametrizedAction aNewTranslateAdd = new ParametrizedAction(Name + "-TranslateAdd"); 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"); cfPreconditions.AddOperand(Preconditions); 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 } 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); } 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 throw new NotImplementedException(); if (Observe != null) { throw new NotImplementedException(); } return lActions; }
public List<Action> KnowWhetherTagCompilationSplitConditions(Dictionary<string, List<Predicate>> dTags, Domain d, List<string> lIncludedTags, List<string> lExcludedTags, List<Predicate> lAdditionalPredicates) { string sName = Name + "-KW"; foreach (string sTag in lIncludedTags) sName += "-" + sTag; ParametrizedAction aNewState = new ParametrizedAction(sName + "-State"); ParametrizedAction aNewKnowledgeGain = new ParametrizedAction(sName + "-KnowledgeGain"); ParametrizedAction aNewKnowledgeLoss = new ParametrizedAction(sName + "-KnowledgeLoss"); ParametrizedPredicate ppInFirst = new ParametrizedPredicate("P1-" + sName); ParametrizedPredicate ppInSecond = new ParametrizedPredicate("P2-" + sName); 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"); Formula cfKWPreconditions = GetKnowWhetherPreconditions(dTags, d, lIncludedTags, lExcludedTags); cfPreconditions.AddOperand(cfKWPreconditions); //knowledge loss is the first action, so it will have all the preconditions cfPreconditions.AddOperand(gpNotInAction); if (Effects == null) throw new NotImplementedException(); HashSet<Predicate> lKnowEffects = new HashSet<Predicate>(); CompoundFormula cfStateEffects = new CompoundFormula("and"); CompoundFormula cfKnowledgeLossEffects = new CompoundFormula("and"); CompoundFormula cfKnowledgeGainEffects = new CompoundFormula("and"); //CompoundFormula cfMandatoryEffects = new CompoundFormula("and"); foreach (Formula f in lObligatory) { f.GetAllPredicates(lKnowEffects); } if (lKnowEffects.Count > 0) { foreach (string sTag in lIncludedTags) { //~KNot t|?t -> effects|t CompoundFormula cfKEffects = new CompoundFormula("and"); foreach (Predicate p in lKnowEffects) { Predicate pAdd = p.GenerateGiven(sTag); cfKEffects.AddOperand(pAdd); if (!d.AlwaysKnown(p)) { pAdd = p.GenerateKnowGiven(sTag, true); cfKEffects.AddOperand(pAdd); } } cfStateEffects.SimpleAddOperand(cfKEffects); } } List<Action> lActions = new List<Action>(); if (lConditions.Count > 0) { lAdditionalPredicates.Add(ppInFirst); lAdditionalPredicates.Add(ppInSecond); aNewKnowledgeLoss.Preconditions = cfPreconditions; aNewKnowledgeGain.Preconditions = new PredicateFormula(ppInFirst); aNewState.Preconditions = new PredicateFormula(ppInSecond); cfKnowledgeLossEffects.AddOperand(ppInFirst); cfKnowledgeLossEffects.AddOperand(gpNotInAction.Negate()); cfKnowledgeGainEffects.AddOperand(ppInSecond); cfKnowledgeGainEffects.AddOperand(ppInFirst.Negate()); cfStateEffects.AddOperand(ppInSecond.Negate()); cfStateEffects.AddOperand(gpNotInAction); foreach (CompoundFormula cfCondition in lConditions) { CompoundFormula cfK = null, cfAnd = null; HashSet<Predicate> lConditionEffects = cfCondition.Operands[1].GetAllPredicates(); cfAnd = new CompoundFormula("and"); foreach (string sTag in lIncludedTags) { cfK = CreateTaggedCondition(cfCondition, d, sTag); if (cfK != null) { cfStateEffects.SimpleAddOperand(cfK); } } cfK = CreateTaggedKnowledgeWhetherGainConditions(cfCondition, d, lIncludedTags); if (cfK != null) { cfKnowledgeGainEffects.SimpleAddOperand(cfK); } cfK = CreateTaggedKnowledgeWhetherLossCondition(cfCondition, d, lIncludedTags); if (cfK != null && cfK.Operands.Count > 0) { cfKnowledgeLossEffects.SimpleAddOperand(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 KnowWhetherTagCompilation(Dictionary<string, List<Predicate>> dTags, Domain d, string sActionTag) { string sName = Name + "-KW-" + sActionTag; ParametrizedAction aNew = new ParametrizedAction(sName); if (this is ParametrizedAction) { foreach (Parameter p in ((ParametrizedAction)this).Parameters) aNew.AddParameter(p); } List<CompoundFormula> lConditions = new List<CompoundFormula>(); List<Formula> lObligatory = new List<Formula>(); SplitEffects(lConditions, lObligatory); aNew.Preconditions = GetKnowWhetherPreconditions(dTags, d, sActionTag); 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); } if (lKnowEffects.Count > 0) { foreach (string sTag in dTags.Keys) { //~KNot t|?t -> effects|t CompoundFormula cfKEffects = new CompoundFormula("and"); foreach (Predicate p in lKnowEffects) { Predicate pAdd = p.GenerateGiven(sTag); cfKEffects.AddOperand(pAdd); //pAdd = p.GenerateKnowGiven(sTag, true); //pAdd = p.GenerateGiven(sTag); //cfKEffects.AddOperand(pAdd); } if (sTag == sActionTag) cfEffects.SimpleAddOperand(cfKEffects); else { CompoundFormula cfCondition = new CompoundFormula("when"); Predicate pNotTag = Predicate.GenerateKNot(new Constant(Domain.TAG, sTag),new Constant(Domain.TAG, sActionTag)); cfCondition.AddOperand(pNotTag.Negate()); cfCondition.AddOperand(cfKEffects); cfEffects.SimpleAddOperand(cfCondition); } } } /* //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, cfAnd = null; HashSet<Predicate> lConditionEffects = cfCondition.Operands[1].GetAllPredicates(); cfAnd = new CompoundFormula("and"); /* //since this action is done only for a part of the states, you lose all information in the effects foreach (Predicate p in lConditionEffects) { if (p.Name != Domain.OPTION_PREDICATE) { Predicate pK = new KnowPredicate(p); cfAnd.AddOperand(pK.Negate()); pK = new KnowPredicate(p.Negate()); cfAnd.AddOperand(pK.Negate()); pK = new KnowWhetherPredicate(p); cfAnd.AddOperand(pK.Negate()); } } if (cfAnd.Operands.Count > 0) cfEffects.SimpleAddOperand(cfAnd); * */ foreach (string sTag in dTags.Keys) { cfK = CreateTaggedCondition(cfCondition, d, sTag); if (cfK != null) { if (sTag == sActionTag) { cfEffects.SimpleAddOperand(cfK); } else { Predicate pNotTag = Predicate.GenerateKNot(new Constant(Domain.TAG, sTag),new Constant(Domain.TAG, sActionTag)); cfAnd = new CompoundFormula("and"); cfAnd.AddOperand(pNotTag.Negate()); if (cfK.Operator == "when") { cfAnd.AddOperand(cfK.Operands[0]); cfK.Operands[0] = cfAnd; cfEffects.SimpleAddOperand(cfK); } else throw new NotImplementedException(); } } } /* cfK = CreateTaggedKnowledgeWhetherGainConditions(cfCondition, d, dTags.Keys, sActionTag); if (cfK != null) { cfEffects.SimpleAddOperand(cfK); } cfK = CreateTaggedKnowledgeWhetherLossCondition(cfCondition, d, dTags.Keys, sActionTag); if (cfK != null && cfK.Operands.Count > 0) { cfEffects.SimpleAddOperand(cfK); } */ } aNew.Effects = cfEffects.Simplify(); } if (Observe != null) { throw new NotImplementedException(); } return aNew; }
public Action KnowWhetherTagCompilation(Dictionary<string, List<Predicate>> dTags, Domain d, List<string> lIncludedTags, List<string> lExcludedTags) { string sName = Name + "-KW"; foreach (string sTag in lIncludedTags) sName += "-" + sTag; ParametrizedAction aNew = new ParametrizedAction(sName); if (this is ParametrizedAction) { foreach (Parameter p in ((ParametrizedAction)this).Parameters) aNew.AddParameter(p); } List<CompoundFormula> lConditions = new List<CompoundFormula>(); List<Formula> lObligatory = new List<Formula>(); SplitEffects(lConditions, lObligatory); aNew.Preconditions = GetKnowWhetherPreconditions(dTags, d, lIncludedTags, lExcludedTags); 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); } if (lKnowEffects.Count > 0) { List<Predicate> lFunctionExpressions = new List<Predicate>(); List<Predicate> lPredicates = new List<Predicate>(); foreach (Predicate p in lKnowEffects) { if (d.IsFunctionExpression(p.Name)) lFunctionExpressions.Add(p); else lPredicates.Add(p); } foreach (string sTag in lIncludedTags) { //~KNot t|?t -> effects|t CompoundFormula cfKEffects = new CompoundFormula("and"); foreach (Predicate p in lPredicates) { Predicate pAdd = p.GenerateGiven(sTag); cfKEffects.AddOperand(pAdd); if (!d.AlwaysKnown(p)) { pAdd = p.GenerateKnowGiven(sTag, true); cfKEffects.AddOperand(pAdd); } } cfEffects.SimpleAddOperand(cfKEffects); } foreach (Predicate p in lFunctionExpressions) cfEffects.AddOperand(p); } List<Predicate> lAllKnowledgeToRemove = new List<Predicate>(); foreach (CompoundFormula cfCondition in lConditions) { CompoundFormula cfK = null, cfAnd = null; HashSet<Predicate> lConditionEffects = cfCondition.Operands[1].GetAllPredicates(); cfAnd = new CompoundFormula("and"); foreach (string sTag in lIncludedTags) { cfK = CreateTaggedCondition(cfCondition, d, sTag); if (cfK != null) { cfEffects.SimpleAddOperand(cfK); } } if (SDRPlanner.RemoveAllKnowledge) { foreach (Predicate p in cfCondition.Operands[1].GetAllPredicates()) { Predicate pTag = p; if (p.Negation) pTag = p.Negate(); if (!lAllKnowledgeToRemove.Contains(pTag)) lAllKnowledgeToRemove.Add(pTag); } } else { cfK = CreateTaggedKnowledgeWhetherGainConditions(cfCondition, d, lIncludedTags); if (cfK != null) { cfEffects.SimpleAddOperand(cfK); } cfK = CreateTaggedKnowledgeWhetherLossCondition(cfCondition, d, lIncludedTags); if (cfK != null && cfK.Operands.Count > 0) { cfEffects.SimpleAddOperand(cfK); } } /* causes the plan to add many merge actions foreach (string sTag in lIncludedTags) { foreach (Predicate pForget in lConditionEffects) { if(pForget.Name != Domain.OPTION_PREDICATE) cfEffects.AddOperand(pForget.GenerateKnowGiven(sTag, true).Negate()); } } * */ } if (SDRPlanner.RemoveAllKnowledge) { foreach (Predicate p in lAllKnowledgeToRemove) { foreach (string sTag in lIncludedTags) { Predicate pNegate = p.GenerateKnowGiven(sTag, true).Negate(); cfEffects.AddOperand(pNegate); } } } aNew.Effects = cfEffects.Simplify(); } if (Observe != null) { throw new NotImplementedException(); } return aNew; }
private void ReadInitState(Problem p, Domain d, CompoundExpression eInitState) { foreach (Expression e in eInitState.SubExpressions) { CompoundExpression eSub = (CompoundExpression)e; if(d.IsFunctionExpression(eSub.Type)) { p.AddKnown(ReadFunctionExpression(eSub, null, d)); } else if (d.ContainsPredicate(eSub.Type)) { p.AddKnown(ReadGroundedPredicate(eSub, d)); } else { if (eSub.Type != "unknown") { Formula f = ReadGroundedFormula(eSub, d); if (f is CompoundFormula) p.AddHidden((CompoundFormula)f); if (f is PredicateFormula)//this happens in (not (p)) statments p.AddKnown(((PredicateFormula)f).Predicate); } else { //causing a problem - add operand does some basic reasoning - adding p and ~p results in true for or statements. //skipping unknown for now... Predicate pUnknown = ReadGroundedPredicate((CompoundExpression)eSub.SubExpressions[0], d); CompoundFormula cfOr = new CompoundFormula("or"); cfOr.SimpleAddOperand(pUnknown); cfOr.SimpleAddOperand(pUnknown.Negate()); p.AddHidden(cfOr); } } } p.ComputeRelevanceClosure(); }
//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; }
public CompoundFormula RemovePredicates(IEnumerable<Predicate> lPredicates) { CompoundFormula cfNew = new CompoundFormula(Operator); foreach (Formula f in Operands) { if (f is PredicateFormula) { if (!lPredicates.Contains(((PredicateFormula)f).Predicate)) cfNew.SimpleAddOperand(f); } else cfNew.SimpleAddOperand(((CompoundFormula)f).RemovePredicates(lPredicates)); } return cfNew; }
private CompoundFormula CreateTaggedKnowledgeWhetherLossCondition(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); bool bContainsOption = false; CompoundFormula cfAllConditions = new CompoundFormula("and"); Predicate pNotTag = null; foreach (Predicate p in lPreconditions) { if (p.Name == Domain.OPTION_PREDICATE) bContainsOption = true; } foreach (string sForgetTag in lTags) { CompoundFormula cfEffects = new CompoundFormula("and"); foreach (Predicate p in lEffects) { if (p.Name != Domain.OPTION_PREDICATE) { Predicate pKEffect = p.GenerateKnowGiven(sForgetTag, true); cfEffects.AddOperand(pKEffect.Negate()); } } if (bContainsOption) { CompoundFormula cfWhen = new CompoundFormula("when"); CompoundFormula cfPreconditions = new CompoundFormula("and"); if (sForgetTag != sActionTag) { pNotTag = Predicate.GenerateKNot(new Constant(Domain.TAG, sForgetTag),new Constant(Domain.TAG, sActionTag)); cfPreconditions.AddOperand(pNotTag.Negate()); cfWhen.AddOperand(cfPreconditions); cfWhen.AddOperand(cfEffects); cfAllConditions.SimpleAddOperand(cfWhen); } else { cfAllConditions.AddOperand(cfEffects); } } else { foreach (string sTag in lTags) { CompoundFormula cfWhen = new CompoundFormula("when"); CompoundFormula cfPreconditions = new CompoundFormula("and"); if (sForgetTag != sActionTag) { pNotTag = Predicate.GenerateKNot(new Constant(Domain.TAG, sForgetTag),new Constant(Domain.TAG, sActionTag)); cfPreconditions.AddOperand(pNotTag.Negate()); } if (sTag != sActionTag) { pNotTag = Predicate.GenerateKNot(new Constant(Domain.TAG, sTag), new Constant(Domain.TAG, sActionTag)); cfPreconditions.AddOperand(pNotTag.Negate()); } CompoundFormula cfOr = new CompoundFormula("or"); foreach (Predicate p in lPreconditions) { Predicate pKGiven = null, pGiven = null; if (d.AlwaysKnown(p) && d.AlwaysConstant(p)) { continue;//there is an underlying assumption here that always known + always constant means that it is also always true } else { if (!d.AlwaysKnown(p)) { pKGiven = p.GenerateKnowGiven(sTag, true); cfOr.AddOperand(pKGiven.Negate()); //pGiven = p.GenerateGiven(sTag); //cfOr.AddOperand(pGiven.Negate()); } } } if(cfOr.Operands.Count > 0) { cfPreconditions.AddOperand(cfOr); cfWhen.AddOperand(cfPreconditions.Simplify()); cfWhen.AddOperand(cfEffects.Simplify()); cfAllConditions.AddOperand(cfWhen); } } } } return cfAllConditions; }
public override Formula ApplyKnown(IEnumerable<Predicate> lKnown) { CompoundFormula cfNew = new CompoundFormula(Operator); if (Operator == "and" || Operator == "or" || Operator == "oneof") { foreach (Formula f in Operands) { Formula fTag = f.ApplyKnown(lKnown); if (fTag != null) cfNew.SimpleAddOperand(fTag); } } else if (Operator == "when") { if (Operands[0].IsTrue(lKnown)) return Operands[1]; if (Operands[0].IsFalse(lKnown)) return null; cfNew.AddOperand(Operands[0].ApplyKnown(lKnown)); cfNew.AddOperand(Operands[1]); } else throw new NotImplementedException(); return cfNew; }
public Formula GetApplicableEffects(IEnumerable<Predicate> lPredicates, bool bContainsNegations) { List<CompoundFormula> lConditions = new List<CompoundFormula>(); List<Formula> lObligatory = new List<Formula>(); SplitEffects(lConditions, lObligatory); CompoundFormula cfEffects = new CompoundFormula("and"); foreach(Formula f in lObligatory) cfEffects.SimpleAddOperand(f); int iCondition = 0; List<Predicate> lEffects = new List<Predicate>(); foreach(CompoundFormula cfWhen in lConditions) { if (cfWhen.Operands[0].ContainedIn(lPredicates, bContainsNegations)) { if (m_mMapConditionsChoices.ContainsKey(iCondition)) { if (cfWhen.Operands[1] is CompoundFormula) { //cfEffects.AddOperand(((CompoundFormula)cfWhen.Operands[1]).Operands[m_mMapConditionsChoices[iCondition].First()]); AddPredicatesToEffectList(lEffects,((CompoundFormula)cfWhen.Operands[1]).Operands[m_mMapConditionsChoices[iCondition].First()]); } } else { //cfEffects.AddOperand(cfWhen.Operands[1]); AddPredicatesToEffectList(lEffects, cfWhen.Operands[1]); } } iCondition++; } foreach (Predicate p in lEffects) { cfEffects.AddOperand(p); } return cfEffects; }
public override Formula ReduceConditions(IEnumerable<Predicate> lKnown) { CompoundFormula cfNew = new CompoundFormula(Operator); if (Operator == "and")// || Operator == "or" || Operator == "oneof") { foreach (Formula f in Operands) { if (f is CompoundFormula) { Formula fTag = f.ReduceConditions(lKnown); if (fTag != null) cfNew.SimpleAddOperand(fTag); } else cfNew.SimpleAddOperand(f); } } else if (Operator == "when") { Formula fReduced = Operands[0].Reduce(lKnown); if(fReduced.IsTrue(null)) return Operands[1]; if (fReduced.IsFalse(null)) return null; cfNew.AddOperand(fReduced); cfNew.AddOperand(Operands[1]); } else throw new NotImplementedException(); return cfNew; }
/* 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; }