public void CompleteKnownState() { List <string> lKnownPredicates = new List <string>(); foreach (Predicate p in m_lKnown) { if (!lKnownPredicates.Contains(p.Name)) { lKnownPredicates.Add(p.Name); } } // List<GroundedPredicate> lGrounded = Domain.GroundAllPredicates(lKnownPredicates); HashSet <GroundedPredicate> lGrounded = Domain.GroundAllPredicates(); HashSet <Predicate> lUnknown = new HashSet <Predicate>(); foreach (Formula f in m_lHidden) { f.GetAllPredicates(lUnknown); } foreach (GroundedPredicate gp in lGrounded) { if (!(Domain.AlwaysConstant(gp) && Domain.AlwaysKnown(gp))) //not sure why I thouhgt that constant predicates do not apply here. We need them for planning in K domain. { if (lUnknown.Contains(gp) || lUnknown.Contains(gp.Negate()) || m_lKnown.Contains(gp) || m_lKnown.Contains(gp.Negate())) { //do nothing } else { m_lKnown.Add(gp.Negate()); } } } }
public override Formula RemoveUniversalQuantifiers(HashSet <Constant> lConstants, List <Predicate> lConstantPredicates, Domain d) { if (d != null && lConstantPredicates != null && d.AlwaysConstant(Predicate) && d.AlwaysKnown(Predicate) && !(Predicate is ParametrizedPredicate)) { Predicate p = Predicate; if (p.Negation) { p = p.Negate(); } bool bContains = lConstantPredicates.Contains(p); //assuming that list does not contain negations if ((bContains && !Predicate.Negation) || (!bContains && Predicate.Negation)) { return(new PredicateFormula(new GroundedPredicate(Domain.TRUE_PREDICATE))); } else { return(new PredicateFormula(new GroundedPredicate(Domain.FALSE_PREDICATE))); } } return(this); }
public Problem ParseProblem(string sProblemFile, Domain d) { StreamReader sr = new StreamReader(sProblemFile); CompoundExpression exp = (CompoundExpression)ToExpression(sr); sr.Close(); Problem p = null; CompoundExpression eSub = null; foreach (Expression e in exp.SubExpressions) { eSub = (CompoundExpression)e; if (eSub.Type == "problem") { p = new Problem(eSub.SubExpressions.First().ToString(), d); } if (eSub.Type == ":domain") { if (eSub.SubExpressions.First().ToString() != d.Name) { throw new InvalidDataException("Domain and problem files don't match!"); } } if (eSub.Type == ":objects") { ReadConstants(eSub, d); } if (eSub.Type == ":init") { CompoundExpression eAnd = (CompoundExpression)eSub.SubExpressions.First(); if (eAnd.Type == "and") { ReadInitState(p, d, eAnd); } else { ReadInitState(p, d, eSub); } //throw new InvalidDataException("Expecting 'and', got " + eAnd.Type); } if (eSub.Type == ":goal") { ReadGoal(p, d, eSub.SubExpressions[0]); } if (eSub.Type == ":metric") { ReadMetric(p, d, eSub); } } //p.AddReasoningActions(); not needed as long as we use FF to do the planning for us d.ComputeAlwaysKnown(); p.CompleteKnownState(); List <Predicate> lConstantPredicates = new List <Predicate>(); foreach (Predicate pKnown in p.Known) { if (d.AlwaysConstant(pKnown)) { lConstantPredicates.Add(pKnown); } } //Problem here - sometimes ~p and p are both effects (remove p and immediately add it), and the current code forbids that - not sure what to do... //d.RemoveUniversalQuantifiers(lConstantPredicates); //p.RemoveUniversalQuantifiers(); d.ComputePrivateActions(); return(p); }
/* * public void WriteTaggedProblemNoState(string sProblemFile, Dictionary<string, List<Predicate>> dTags, IEnumerable<Predicate> lObserved, * Dictionary<string, double> dFunctionValues) * { * StreamWriter sw = new StreamWriter(sProblemFile); * sw.WriteLine("(define (problem K" + Name + ")"); * sw.WriteLine("(:domain K" + Domain.Name + ")"); * sw.WriteLine("(:init"); //ff doesn't like the and (and"); * * string sKP = ""; * if (Domain.TIME_STEPS > 0) * sw.WriteLine("(time0)"); * foreach (KeyValuePair<string, double> f in dFunctionValues) * { * sw.WriteLine("(= " + f.Key + " " + f.Value + ")"); * } * foreach (GroundedPredicate gp in lObserved) * { * //if (gp.Negation) * // continue; * if (gp.Name == "Choice" || gp.Name == Domain.OPTION_PREDICATE) * continue; * if (Domain.AlwaysKnown(gp) && Domain.AlwaysConstant(gp)) * { * sKP = "(K" + gp.Name; * foreach (Constant c in gp.Constants) * { * sKP += " " + c.Name; * } * if (gp.Negation) * sKP += " " + Domain.FALSE_VALUE; * else * sKP += " " + Domain.TRUE_VALUE; * * sw.WriteLine(sKP + ")"); * } * else * { * foreach (string sTag in dTags.Keys) * { * if (!gp.Negation) * sw.WriteLine(gp.GenerateGiven(sTag)); * if (!Domain.AlwaysKnown(gp)) * sw.WriteLine(gp.GenerateKnowGiven(sTag, true)); * } * } * } * foreach (KeyValuePair<string, List<Predicate>> p in dTags) * { * * foreach (GroundedPredicate gp in p.Value) * { * if (gp.Negation) * continue; * if (gp.Name == "Choice") * continue; * if (!gp.Negation) * { * sKP = GenerateKnowGivenLine(gp, p.Key, false); * sw.WriteLine(sKP); * } * //sKP = GenerateKnowGivenLine(gp, p.Key, true); * //sw.WriteLine(sKP); * } * * if (SDRPlanner.AddAllKnownToGiven) * { * foreach (GroundedPredicate gp in lObserved) * { * //if (gp.Negation) * // continue; * if (gp.Name == "Choice") * continue; * if (!(Domain.AlwaysKnown(gp) && Domain.AlwaysConstant(gp))) * { * if (!gp.Negation) * { * sKP = GenerateKnowGivenLine(gp, p.Key, false); * sw.WriteLine(sKP); * } * } * if (!(Domain.AlwaysKnown(gp)) && gp.Name != Domain.OPTION_PREDICATE) * { * sKP = GenerateKnowGivenLine(gp, p.Key, true); * sw.WriteLine(sKP); * } * } * } * * } * * //if (Problem.Domain.HasNonDeterministicActions()) * // sw.WriteLine("(option opt0)"); * * if (SDRPlanner.SplitConditionalEffects) * sw.WriteLine("(NotInAction)"); * * sw.WriteLine(")"); * * CompoundFormula cfGoal = new CompoundFormula("and"); * * List<Predicate> lGoalPredicates = new List<Predicate>(); * Goal.GetAllPredicates(lGoalPredicates); * * * for (int iTag = 0; iTag < dTags.Count; iTag++) * { * if (SDRPlanner.ConsiderStateNegations && iTag == dTags.Count - 1) * break; * string sTag = dTags.Keys.ElementAt(iTag); * foreach (Predicate p in lGoalPredicates) * { * if (!Domain.AlwaysKnown(p) || !Domain.AlwaysConstant(p)) * { * cfGoal.AddOperand(p.GenerateGiven(sTag)); * if (!Domain.AlwaysKnown(p)) * cfGoal.AddOperand(p.GenerateKnowGiven(sTag, true)); * } * } * } * * * sw.WriteLine("(:goal " + cfGoal + ")"); * //sw.WriteLine("))"); * if (MetricStatement != null) * { * sw.WriteLine(MetricStatement); * } * sw.WriteLine(")"); * sw.Close(); * } */ public void WriteTaggedProblemNoState(string sProblemFile, Dictionary <string, List <Predicate> > dTags, IEnumerable <Predicate> lObserved, Dictionary <string, double> dFunctionValues) { StreamWriter sw = new StreamWriter(sProblemFile); sw.WriteLine("(define (problem K" + Name + ")"); sw.WriteLine("(:domain K" + Domain.Name + ")"); sw.WriteLine("(:init"); //ff doesn't like the and (and"); string sKP = ""; if (Domain.TIME_STEPS > 0) { sw.WriteLine("(time0)"); } foreach (KeyValuePair <string, double> f in dFunctionValues) { sw.WriteLine("(= " + f.Key + " " + f.Value + ")"); } foreach (GroundedPredicate gp in lObserved) { //if (gp.Negation) // continue; if (gp.Name == "Choice" || gp.Name == Domain.OPTION_PREDICATE) { continue; } if (Domain.AlwaysKnown(gp) && Domain.AlwaysConstant(gp)) { sKP = "(" + gp.Name; foreach (Constant c in gp.Constants) { sKP += " " + c.Name; } sw.WriteLine(sKP + ")"); } else { foreach (string sTag in dTags.Keys) { if (!gp.Negation) { Predicate pGiven = gp.GenerateGiven(sTag); sw.WriteLine(pGiven); } } } } foreach (KeyValuePair <string, List <Predicate> > p in dTags) { foreach (GroundedPredicate gp in p.Value) { if (gp.Negation) { continue; } if (gp.Name == "Choice") { continue; } if (!gp.Negation) { sw.WriteLine(gp.GenerateGiven(p.Key)); } //sKP = GenerateKnowGivenLine(gp, p.Key, true); //sw.WriteLine(sKP); } } //if (Problem.Domain.HasNonDeterministicActions()) // sw.WriteLine("(option opt0)"); //if (SDRPlanner.SplitConditionalEffects) sw.WriteLine("(NotInAction)"); sw.WriteLine(")"); CompoundFormula cfGoal = new CompoundFormula("and"); HashSet <Predicate> lGoalPredicates = new HashSet <Predicate>(); Goal.GetAllPredicates(lGoalPredicates); for (int iTag = 0; iTag < dTags.Count; iTag++) { if (SDRPlanner.ConsiderStateNegations && iTag == dTags.Count - 1) { break;//What is that? } string sTag = dTags.Keys.ElementAt(iTag); foreach (Predicate p in lGoalPredicates) { if (!Domain.AlwaysKnown(p) || !Domain.AlwaysConstant(p)) { cfGoal.AddOperand(p.GenerateGiven(sTag)); } } } if (SDRPlanner.ForceTagObservations) { foreach (string sTag1 in dTags.Keys) { foreach (string sTag2 in dTags.Keys) { if (sTag1 != sTag2) { GroundedPredicate gpNot = new GroundedPredicate("Knot"); gpNot.AddConstant(new Constant(Domain.TAG, sTag1)); gpNot.AddConstant(new Constant(Domain.TAG, sTag2)); cfGoal.AddOperand(gpNot); } } } } sw.WriteLine("(:goal " + cfGoal + ")"); //sw.WriteLine("))"); if (MetricStatement != null) { sw.WriteLine(MetricStatement); } sw.WriteLine(")"); sw.Close(); }