public void AddConstant(Constant c)
{
((List<Constant>)Constants).Add(c);
m_sCachedToString = null;
}
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
{
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 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;
}
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;
}
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;
}
