public GroundedPredicate Ground(Dictionary <string, Constant> dBindings)
{
GroundedPredicate gp = new GroundedPredicate("K" + Knowledge.Name);
if (Knowledge is ParametrizedPredicate)
{
foreach (Argument a in ((ParametrizedPredicate)Knowledge).Parameters)
{
if (a is Parameter)
{
if (dBindings.ContainsKey(a.Name))
{
gp.AddConstant(dBindings[a.Name]);
}
else
{
throw new NotImplementedException();
}
}
else
{
gp.AddConstant((Constant)a);
}
}
}
else
{
foreach (Constant c in ((GroundedPredicate)Knowledge).Constants)
{
gp.AddConstant(c);
}
}
return(gp);
}
public GroundedPredicate Ground(Dictionary <string, Constant> dBindings)
{
GroundedPredicate gpred = GroundedPredicateFactory.Get(Name, m_lParameters, dBindings, Negation);
if (gpred != null)
{
return(gpred);
}
gpred = new GroundedPredicate(Name, Negation);
foreach (Argument a in Parameters)
{
if (a is Parameter)
{
if (!dBindings.ContainsKey(a.Name))
{
return(null);
}
gpred.AddConstant(dBindings[a.Name]);
}
else
{
gpred.AddConstant((Constant)a);
}
}
GroundedPredicateFactory.Add(Name, m_lParameters, dBindings, gpred, Negation);
return(gpred);
}
private static GroundedPredicate GetSafe(int iX, int iY)
{
GroundedPredicate gpSafe = new GroundedPredicate("safe");
gpSafe.AddConstant(new Constant("pos", "p-" + iX));
gpSafe.AddConstant(new Constant("pos", "p-" + iY));
return(gpSafe);
}
private static GroundedPredicate GetPredicate(string sName, int iX, int iY)
{
GroundedPredicate gpSafe = new GroundedPredicate(sName);
gpSafe.AddConstant(new Constant("pos", "p-" + iX));
gpSafe.AddConstant(new Constant("pos", "p-" + iY));
return(gpSafe);
}
public Predicate ReadFunctionExpression(CompoundExpression exp, Dictionary <string, string> dParameterNameToType, Domain d)
{
Constant c = null;
string sName = exp.SubExpressions[0].ToString();
if (exp.Type == "=")
{
string sParam1 = exp.SubExpressions[0].ToString();
string sParam2 = exp.SubExpressions[1].ToString();
if (!dParameterNameToType.ContainsKey(sParam1))
{
throw new ArgumentException("First argument of = must be a parameter");
}
ParametrizedPredicate pp = new ParametrizedPredicate("=");
pp.AddParameter(new Parameter(dParameterNameToType[sParam1], sParam1));
if (dParameterNameToType.ContainsKey(sParam2))
{
pp.AddParameter(new Parameter(dParameterNameToType[sParam2], sParam2));
}
else
{
pp.AddParameter(new Constant(d.ConstantNameToType[sParam2], sParam2));
}
return(pp);
}
GroundedPredicate p = new GroundedPredicate(exp.Type);
double dValue = 0.0;
if (d.Functions.Contains(sName))
{
c = new Constant("Function", sName);
}
else
{
throw new ArgumentException("First argument of increase or decrease must be a function");
}
p.AddConstant(c);
sName = exp.SubExpressions[1].ToString();
if (double.TryParse(sName, out dValue))
{
c = new Constant("Number", sName);
}
else
{
throw new ArgumentException("Second argument of increase or decrease must be a number");
}
p.AddConstant(c);
return(p);
}
private void AddEffects(Formula fEffects)
{
if (fEffects is PredicateFormula)
{
AddEffect(((PredicateFormula)fEffects).Predicate);
}
else
{
CompoundFormula cf = (CompoundFormula)fEffects;
if (cf.Operator == "oneof" || cf.Operator == "or")//BUGBUG - should treat or differently
{
int iRandomIdx = RandomGenerator.Next(cf.Operands.Count);
AddEffects(cf.Operands[iRandomIdx]);
GroundedPredicate pChoice = new GroundedPredicate("Choice");
pChoice.AddConstant(new Constant("ActionIndex", "a" + (Time - 1)));//time - 1 because this is the action that generated the state, hence its index is i-1
pChoice.AddConstant(new Constant("ChoiceIndex", "c" + iRandomIdx));
State s = this;
while (s != null)
{
s.m_lPredicates.Add(pChoice);
s = s.m_sPredecessor;
}
}
else if (cf.Operator == "and")
{
foreach (Formula f in cf.Operands)
{
if (f is PredicateFormula)
{
AddEffect(((PredicateFormula)f).Predicate);
}
else
{
AddEffects(f);
}
}
}
else if (cf.Operator == "when")
{
if (m_sPredecessor.Contains(cf.Operands[0]))
{
AddEffects(cf.Operands[1]);
}
}
else
{
throw new NotImplementedException();
}
}
}
public override Predicate GenerateGiven(string sTag)
{
GroundedPredicate pGiven = new GroundedPredicate("Given" + Name);
foreach (Constant c in Constants)
{
pGiven.AddConstant(c);
}
pGiven.AddConstant(new Constant(Domain.TAG, sTag));
if (Negation)
{
return(pGiven.Negate());
}
return(pGiven);
}
public Predicate PartiallyGround(Dictionary <string, Constant> dBindings)
{
GroundedPredicate gpred = new GroundedPredicate(Name, Negation);
ParametrizedPredicate ppred = new ParametrizedPredicate(Name, Negation);
bool bAllGrounded = true;
foreach (Argument a in Parameters)
{
if (a is Parameter)
{
if (!dBindings.ContainsKey(a.Name))
{
ppred.AddParameter(a);
bAllGrounded = false;
}
else
{
ppred.AddParameter(dBindings[a.Name]);
gpred.AddConstant(dBindings[a.Name]);
}
}
else
{
gpred.AddConstant((Constant)a);
ppred.AddParameter(a);
}
}
if (bAllGrounded)
{
if (gpred.Name == "=")
{
bool bSame = gpred.Constants[0].Equals(gpred.Constants[1]);
if (bSame && !Negation || !bSame && Negation)
{
return(Domain.TRUE_PREDICATE);
}
else
{
return(Domain.FALSE_PREDICATE);
}
}
return(gpred);
}
else
{
return(ppred);
}
}
//for MPSR
public static Predicate GenerateKNot(Constant cTag1, Constant cTag2)
{
GroundedPredicate gp = new GroundedPredicate("KNot");
int iTag1 = int.Parse(cTag1.Name.Substring(3));
int iTag2 = int.Parse(cTag2.Name.Substring(3));
if (iTag1 < iTag2)
{
gp.AddConstant(cTag1);
gp.AddConstant(cTag2);
}
else
{
gp.AddConstant(cTag2);
gp.AddConstant(cTag1);
}
return(gp);
}
private GroundedPredicate ReadGroundedPredicate(CompoundExpression exp, Domain d)
{
GroundedPredicate gp = new GroundedPredicate(exp.Type);
int iExpression = 0;
Constant c = null;
string sName = "";
for (iExpression = 0; iExpression < exp.SubExpressions.Count; iExpression++)
{
sName = exp.SubExpressions[iExpression].ToString();
c = d.GetConstant(sName);
gp.AddConstant(c);
}
return(gp);
}
private Formula ReadPredicate(CompoundExpression exp, Dictionary <string, string> dParameterNameToType, bool bParametrized, Domain d)
{
Predicate p = null;
int iExpression = 0;
string sName = "";
if (bParametrized)
{
p = new ParametrizedPredicate(exp.Type);
}
else
{
p = new GroundedPredicate(exp.Type);
}
bool bAllConstants = true;
for (iExpression = 0; iExpression < exp.SubExpressions.Count; iExpression++)
{
sName = exp.SubExpressions[iExpression].ToString();
if (bParametrized)
{
Argument a = null;
if (sName.StartsWith("?"))
{
a = new Parameter(dParameterNameToType[sName], sName);
bAllConstants = false;
}
else
{
if (!d.ConstantNameToType.ContainsKey(sName))
{
throw new Exception("Predicate " + sName + " undefined");
}
a = new Constant(d.ConstantNameToType[sName], sName);
}
((ParametrizedPredicate)p).AddParameter(a);
}
else
{
try
{
Constant c = new Constant(d.ConstantNameToType[sName], sName);
((GroundedPredicate)p).AddConstant(c);
}
catch (Exception e)
{
Console.WriteLine();
}
}
}
if (bParametrized)
{
if (!MatchParametersToPredicateDeclaration((ParametrizedPredicate)p, d))
{
throw new NotImplementedException();
}
}
if (bParametrized && bAllConstants)
{
GroundedPredicate gp = new GroundedPredicate(p.Name);
foreach (Constant c in ((ParametrizedPredicate)p).Parameters)
{
gp.AddConstant(c);
}
p = gp;
}
PredicateFormula vf = new PredicateFormula(p);
return(vf);
}
public static List <string> MasterMindHeuristic(PartiallySpecifiedState pssCurrent, Domain domain)
{
List <Constant> lColors = new List <Constant>();
List <Constant> lPegs = new List <Constant>();
List <Constant> lValues = new List <Constant>();
foreach (Constant c in domain.Constants)
{
if (c.Type.ToLower() == "color")
{
lColors.Add(c);
}
if (c.Type.ToLower() == "peg")
{
lPegs.Add(c);
}
if (c.Type.ToLower() == "value")
{
lValues.Add(c);
}
}
//DateTime dtStart = DateTime.Now;
//BeliefState bs = pssCurrent.m_bsInitialBelief;
//State s = bs.ChooseState(true);
//List<Predicate> l = bs.RunSatSolver();
//Console.WriteLine((DateTime.Now - dtStart).TotalSeconds);
Permute(lColors);
List <Constant> lGuessColors = new List <Constant>();
for (int iPeg = 0; iPeg < lPegs.Count; iPeg++)
{
/*
* //foreach (GroundedPredicate gp in s.Predicates)
* foreach (GroundedPredicate gp in l)
* {
* if (gp.ToString().StartsWith("(on p" + iPeg) && gp.Negation == false)
* {
* lGuessColors.Add(gp.Constants[1]);
* }
*
*
* }
*/
foreach (Constant cColor in lColors)
{
GroundedPredicate gp = new GroundedPredicate("on");
gp.AddConstant(lPegs[iPeg]);
gp.AddConstant(cColor);
if (!pssCurrent.Observed.Contains(gp.Negate()))
{
lGuessColors.Add(cColor);
break;
}
}
lColors.Remove(lGuessColors.Last());
}
if (lGuessColors.Count == lPegs.Count)
{
List <string> lActions = new List <string>();
string sGuess = "guess-all";
foreach (Constant c in lGuessColors)
{
sGuess += " " + c.Name;
}
lActions.Add(sGuess);
lActions.Add("evaluate-guess");
foreach (Constant cValue in lValues)
{
lActions.Add("observe-LocationHits " + cValue.Name);
lActions.Add("observe-ColorHits " + cValue.Name);
}
return(lActions);
}
return(null);
}
public static List <string> LargeWumpusHeuristic(PartiallySpecifiedState pssCurrent, Domain d)
{
List <string> lActions = new List <string>();
GroundedPredicate gpAtX = null, gpAtY = null;
foreach (GroundedPredicate gp in pssCurrent.Observed)
{
if (!gp.Negation)
{
if (gp.Name == "at-x")
{
gpAtX = gp;
}
if (gp.Name == "at-y")
{
gpAtY = gp;
}
}
}
string sX = gpAtX.Constants[0].Name;
string sY = gpAtY.Constants[0].Name;
int iX = int.Parse(sX.Split('-')[1]);
int iY = int.Parse(sY.Split('-')[1]);
VisitedLocations.Add(iX * 1000 + iY);
GroundedPredicate gpAlive = new GroundedPredicate("alive");
if (pssCurrent.Hidden.Contains(gpAlive))
{
lActions.Add("check-alive_" + sX + "_" + sY);
}
GroundedPredicate gpStench = new GroundedPredicate("stench");
gpStench.AddConstant(gpAtX.Constants[0]);
gpStench.AddConstant(gpAtY.Constants[0]);
if (pssCurrent.Hidden.Contains(gpStench))
{
lActions.Add("smell-wumpus " + sX + " " + sY);
}
GroundedPredicate gpBreeze = new GroundedPredicate("breeze");
gpBreeze.AddConstant(gpAtX.Constants[0]);
gpBreeze.AddConstant(gpAtY.Constants[0]);
if (pssCurrent.Hidden.Contains(gpBreeze))
{
lActions.Add("feel-breeze " + sX + " " + sY);
}
GroundedPredicate gpGold = new GroundedPredicate("gold-at");
gpGold.AddConstant(gpAtX.Constants[0]);
gpGold.AddConstant(gpAtY.Constants[0]);
if (pssCurrent.Hidden.Contains(gpGold))
{
lActions.Add("observe-gold " + sX + " " + sY);
}
if (lActions.Count == 0)
{
List <string> lNotVisited = new List <string>();
List <string> lSafe = new List <string>();
if (iX > 1)
{
if (!VisitedLocations.Contains((iX - 1) * 1000 + iY))
{
lNotVisited.Add("move-left");
}
if (pssCurrent.Observed.Contains(GetSafe(iX - 1, iY)))
{
lSafe.Add("move-left");
}
}
if (iX < Size)
{
if (!VisitedLocations.Contains((iX + 1) * 1000 + iY))
{
lNotVisited.Add("move-right");
}
if (pssCurrent.Observed.Contains(GetSafe(iX + 1, iY)))
{
lSafe.Add("move-right");
}
}
if (iY > 1)
{
if (!VisitedLocations.Contains(iX * 1000 + (iY - 1)))
{
lNotVisited.Add("move-up");
}
if (pssCurrent.Observed.Contains(GetSafe(iX, iY - 1)))
{
lSafe.Add("move-up");
}
}
if (iY < Size)
{
if (!VisitedLocations.Contains(iX * 1000 + (iY + 1)))
{
lNotVisited.Add("move-down");
}
if (pssCurrent.Observed.Contains(GetSafe(iX, iY + 1)))
{
lSafe.Add("move-down");
}
}
List <string> lSafeAndNotVisited = new List <string>(lSafe.Intersect(lNotVisited));
if (lSafeAndNotVisited.Count > 0)
{
int idx = RandomGenerator.Next(lSafeAndNotVisited.Count);
lActions.Add(lSafeAndNotVisited[idx]);
}
else if (lSafe.Count > 0)
{
int idx = RandomGenerator.Next(lSafe.Count);
lActions.Add(lSafe[idx]);
}
else
{
int idx = RandomGenerator.Next(4);
if (idx == 0)
{
lActions.Add("move-down");
}
if (idx == 1)
{
lActions.Add("move-up");
}
if (idx == 2)
{
lActions.Add("move-left");
}
if (idx == 3)
{
lActions.Add("move-right");
}
}
}
return(lActions);
}
private void GetApplicableEffects(Formula fEffects, HashSet <Predicate> lAdd, HashSet <Predicate> lDelete)
{
if (fEffects is PredicateFormula)
{
Predicate p = ((PredicateFormula)fEffects).Predicate;
if (p.Negation)
{
lDelete.Add(p);
}
else
{
lAdd.Add(p);
}
}
else if (fEffects is ProbabilisticFormula)
{
ProbabilisticFormula pf = (ProbabilisticFormula)fEffects;
double dRand = RandomGenerator.NextDouble();
double dInitialRand = dRand;
int iOption = 0;
while (iOption < pf.Options.Count && dRand > 0)
{
dRand -= pf.Probabilities[iOption];
iOption++;
}
if (dRand < 0.01)
{
iOption--;
GetApplicableEffects(pf.Options[iOption], lAdd, lDelete);
}
else //the no-op option was chosen
{
iOption = -1;
}
GroundedPredicate pChoice = new GroundedPredicate("Choice");
pChoice.AddConstant(new Constant("ActionIndex", "a" + Time));
pChoice.AddConstant(new Constant("ChoiceIndex", "c" + ChoiceCount + "." + iOption));
ChoiceCount++;
State s = this;
while (s != null)
{
s.m_lPredicates.Add(pChoice);
s = s.m_sPredecessor;
}
}
else
{
CompoundFormula cf = (CompoundFormula)fEffects;
if (cf.Operator == "oneof" || cf.Operator == "or")//BUGBUG - should treat or differently
{
int iRandomIdx = RandomGenerator.Next(cf.Operands.Count);
GetApplicableEffects(cf.Operands[iRandomIdx], lAdd, lDelete);
GroundedPredicate pChoice = new GroundedPredicate("Choice");
pChoice.AddConstant(new Constant("ActionIndex", "a" + Time));
pChoice.AddConstant(new Constant("ChoiceIndex", "c" + ChoiceCount + "." + iRandomIdx));
ChoiceCount++;
State s = this;
while (s != null)
{
s.m_lPredicates.Add(pChoice);
s = s.m_sPredecessor;
}
}
else if (cf.Operator == "and")
{
foreach (Formula f in cf.Operands)
{
GetApplicableEffects(f, lAdd, lDelete);
}
}
else if (cf.Operator == "when")
{
if (Contains(cf.Operands[0]))
{
GetApplicableEffects(cf.Operands[1], lAdd, lDelete);
}
}
else if (cf is ParametrizedFormula)
{
ParametrizedFormula pf = (ParametrizedFormula)cf;
foreach (Formula fNew in pf.Ground(Problem.Domain.Constants))
{
GetApplicableEffects(fNew, lAdd, lDelete);
}
}
else
{
throw new NotImplementedException();
}
}
}
public MemoryStream WriteKnowledgeProblem(HashSet <Predicate> lObserved, HashSet <Predicate> lHidden, int cMinMishaps, int cMishaps)
{
MemoryStream msProblem = new MemoryStream();
StreamWriter sw = new StreamWriter(msProblem);
sw.WriteLine("(define (problem K" + Name + ")");
sw.WriteLine("(:domain K" + Domain.Name + ")");
sw.WriteLine(";;" + SDRPlanner.Translation);
sw.WriteLine("(:init"); //ff doesn't like the and (and");
string sKP = "", sP = "";
foreach (GroundedPredicate gp in lObserved)
{
if (gp.Name == "Choice")
{
continue;
}
if (Domain.AlwaysKnown(gp))
{
sw.WriteLine(gp);
}
if (!Domain.AlwaysKnown(gp))
{
Predicate kp = new KnowPredicate(gp);
sw.WriteLine(kp);
}
}
foreach (GroundedPredicate gp in lHidden)
{
//GroundedPredicate kp = new GroundedPredicate(gp);
//kp.Name = "NotK" + kp.Name;
//sw.WriteLine(kp);
}
if (cMinMishaps > cMishaps)
{
sw.WriteLine("(MishapCount m" + cMishaps + ")");
}
sw.WriteLine(")");
HashSet <Predicate> lGoalPredicates = Goal.GetAllPredicates();
CompoundFormula cfGoal = new CompoundFormula("and");
foreach (Predicate p in lGoalPredicates)
{
if (Domain.AlwaysKnown(p))
{
cfGoal.AddOperand(p);
}
else
{
cfGoal.AddOperand(new KnowPredicate(p));
}
}
CompoundFormula cfAnd = new CompoundFormula(cfGoal);
if (cMinMishaps > cMishaps && SDRPlanner.Translation != SDRPlanner.Translations.Conformant)
{
GroundedPredicate gp = new GroundedPredicate("MishapCount");
gp.AddConstant(new Constant("mishaps", "m" + cMinMishaps));
cfAnd.AddOperand(gp);
}
sw.WriteLine("(:goal " + cfAnd.Simplify() + ")");
//sw.WriteLine("))");
sw.WriteLine(")");
sw.Flush();
return(msProblem);
}
