public override int Similarity(Predicate p) { if (Negation != p.Negation) { //if (Name != p.Name || Negation != p.Negation) return(0); } if (p is GroundedPredicate) { GroundedPredicate gpGrounded = (GroundedPredicate)p; int iSimilarity = 0; if (Name == p.Name) { for (int i = 0; i < Constants.Count; i++) { if (Constants[i].Equals(gpGrounded.Constants[i])) { iSimilarity++; } } } else { foreach (Constant c in Constants) { if (gpGrounded.Constants.Contains(c)) { iSimilarity++; } } } return(iSimilarity); } return(0); }
public GroundedPredicate Ground(Dictionary <string, Constant> dBindings) { GroundedPredicate gpred = GroundedPredicateFactory.Get(Name, m_lParameters, dBindings, Negation); /*if (gpred != null) * { * return gpred; * }*///sagi 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); }
public override Predicate GenerateKnowGiven(string sTag, bool bKnowWhether) { GroundedPredicate pKGiven = null; if (bKnowWhether) { pKGiven = new GroundedPredicate("KWGiven" + Name); } else { pKGiven = new GroundedPredicate("KGiven" + Name); } foreach (Constant c in Constants) { pKGiven.AddConstant(c); } pKGiven.AddConstant(new Constant(Domain.TAG, sTag)); if (!bKnowWhether) { if (Negation) { pKGiven.AddConstant(new Constant(Domain.VALUE, Domain.FALSE_VALUE)); } else { pKGiven.AddConstant(new Constant(Domain.VALUE, Domain.TRUE_VALUE)); } } return(pKGiven); }
public override bool ConsistentWith(Predicate p) { if (Name != p.Name) { return(true); //irrelvant predicate - no contradiction } if (p is ParameterizedPredicate) { //TODO throw new NotImplementedException(); } GroundedPredicate gp = (GroundedPredicate)p; if (((List <Constant>)Constants).Count != ((List <Constant>)gp.Constants).Count) { return(true); } for (int i = 0; i < Constants.Count; i++) { if (!gp.Constants[i].Equals(Constants[i])) { return(true);//irrelvant predicate - no contradiction } } return(Negation == p.Negation); }
public GroundedPredicate Ground(Dictionary <string, Constant> dBindings) { GroundedPredicate gp = new GroundedPredicate("K" + Knowledge.Name); if (Knowledge is ParameterizedPredicate) { foreach (Argument a in ((ParameterizedPredicate)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(string sName) : base(sName) { //if (sName == Domain.FALSE_PREDICATE) // Debug.WriteLine("Initialized a false predicate"); m_gpNegation = null; Constants = new List <Constant>(); }
public override Predicate Negate() { if (m_gpNegation == null) { m_gpNegation = new GroundedPredicate(this); m_gpNegation.Negation = !Negation; m_gpNegation.m_gpNegation = this; } return(m_gpNegation); }
public static GroundedPredicate Get(string sName, List <Argument> lParameters, Dictionary <string, Constant> dBindings, bool bNegation) { string sFullName = GetString(sName, lParameters, dBindings, bNegation); GroundedPredicate gp = null; if (AllGrounded.TryGetValue(sFullName, out gp)) { return(gp); } return(null); }
public static void Add(string sName, List <Argument> lParameters, Dictionary <string, Constant> dBindings, GroundedPredicate gp, bool bNegation) { string sFullName = GetString(sName, lParameters, dBindings, bNegation); string sNotFullName = GetString(sName, lParameters, dBindings, !bNegation); gp.Cached = true; AllGrounded[sFullName] = gp; GroundedPredicate gpNot = (GroundedPredicate)gp.Negate(); gpNot.Cached = true; AllGrounded[sNotFullName] = gpNot; }
public GroundedPredicate(GroundedPredicate gpOther) : base(gpOther.Name, gpOther.Negation) { //if (gpOther == Domain.FALSE_PREDICATE || gpOther == Domain.TRUE_PREDICATE) //Console.Write("*"); List <Constant> newConstants = new List <Constant>(); foreach (var item in gpOther.Constants) { newConstants.Add(new Constant(item.Type, item.Name)); } Constants = newConstants; }
public RegressedPredicate(GroundedPredicate pCurrent, Predicate pNext, int iChoice) : base(pCurrent) { Choice = iChoice; if (pNext is RegressedPredicate) { Next = (RegressedPredicate)pNext; } else { Next = null; } }
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); ParameterizedPredicate ppred = new ParameterizedPredicate(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); } }
public override Predicate ToTag() { GroundedPredicate gpNew = new GroundedPredicate(this); if (Negation) { gpNew.Name = gpNew.Name + "-Remove"; } else { gpNew.Name = gpNew.Name + "-Add"; } gpNew.Negation = false; return(gpNew); }
//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); }
public Dictionary <string, Constant> Match(GroundedPredicate pOther, Dictionary <string, Constant> dBindings) { if (pOther.Name != Name) { return(null); } //if (pOther.Negation != Negation) // return null; if (pOther.Constants.Count != m_lParameters.Count) { return(null); } int i = 0; Dictionary <string, Constant> dNewBindings = new Dictionary <string, Constant>(); for (i = 0; i < pOther.Constants.Count; i++) { Argument a = m_lParameters[i]; if (a is Constant) { if (pOther.Constants[i].Name != a.Name) { return(null); } } else if (a is Parameter) { if (dBindings.ContainsKey(a.Name)) { if (!pOther.Constants[i].Equals(dBindings[a.Name])) { return(null); } } else { dNewBindings[a.Name] = pOther.Constants[i]; } } } return(dNewBindings); }
public KnowGivenPredicate(GroundedPredicate p, bool bValue, string sTag, bool bKnowWhether) : base((bKnowWhether ? "KWGiven" : "KGiven") + p.Name) { KnowWhether = bKnowWhether; Predicate = p; Tag = sTag; Value = bValue; Constants = new List <Constant>(p.Constants); Constants.Add(new Constant(Domain.TAG, Tag)); if (!bKnowWhether) { if (Value) { Constants.Add(new Constant(Domain.VALUE, Domain.TRUE_VALUE)); } else { Constants.Add(new Constant(Domain.VALUE, Domain.FALSE_VALUE)); } } }
public override bool SameInvariant(Predicate p, Argument aInvariant) { if (Name != p.Name) { return(false); } if (p is GroundedPredicate) { GroundedPredicate gpGrounded = (GroundedPredicate)p; for (int i = 0; i < Constants.Count; i++) { if (Constants[i].Equals(aInvariant) && !gpGrounded.Constants[i].Equals(aInvariant)) { return(false); } } return(true); } return(false); }