public static List<string> RockSampleHeuristic(PartiallySpecifiedState pssCurrent, Domain domain) { List<string> lActions = new List<string>(); int iX = -1, iY = 1; int iSize = 0; foreach (GroundedPredicate p in pssCurrent.Observed) { if (p.Name.Contains("agent-at")) { string[] a = p.Constants[0].Name.Substring(1).Split('-'); if (!p.Negation) { iX = int.Parse(a[0]); iY = int.Parse(a[1]); } if (int.Parse(a[0]) > iSize) iSize = int.Parse(a[0]); } } int iXNew = iX, iYNew = iY; if (iX < iSize - 1 && iY % 2 == 1) iXNew++; else if (iX > 1 && iY % 2 == 0) iXNew--; else { iYNew++; } lActions.Add("move p" + iX + "-" + iY + " p" + iXNew + "-" + iYNew); bool bValidSensorH1 = false; bool bValidSensorH0 = false; foreach (Action a in domain.Actions) { if (a.Name == "activate-sensor-at-p" + iXNew + "-" + iYNew + "-h1") bValidSensorH1 = true; if (a.Name == "activate-sensor-at-p" + iXNew + "-" + iYNew + "-h0") bValidSensorH0 = true; } if (bValidSensorH1) { lActions.Add("raise-antena"); lActions.Add("activate-sensor-at-p" + iXNew + "-" + iYNew + "-h1"); lActions.Add("observe-sensor"); lActions.Add("lower-antena"); } if(bValidSensorH0) { lActions.Add("activate-sensor-at-p" + iXNew + "-" + iYNew + "-h0"); lActions.Add("observe-sensor"); } return lActions; }
public bool ValidatePlan(PartiallySpecifiedState pssCurrent) { if(pssCurrent == null) return false; if (pssCurrent.IsGoalState()) return true; if (Action == null) return false; Formula fObserved = null; PartiallySpecifiedState psTrueState, psFalseState; pssCurrent.ApplyOffline(Action, out fObserved, out psTrueState, out psFalseState); if (Action.Observe == null) return SingleChild.ValidatePlan(psTrueState); bool bTrueOk = TrueObservationChild.ValidatePlan(psTrueState); bool bFalseOk = FalseObservationChild.ValidatePlan(psFalseState); return bTrueOk && bFalseOk; }
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 virtual PartiallySpecifiedState Clone() { BeliefState bsCopy = new BeliefState(m_bsInitialBelief); PartiallySpecifiedState bsClone = new PartiallySpecifiedState(this, bsCopy); return bsClone; }
public PartiallySpecifiedState(PartiallySpecifiedState original, BeliefState bsInitial) { ID = STATE_COUNT++; m_nPlan = original.m_nPlan; m_lHistory = new List<string>(original.m_lHistory); ChildCount = original.ChildCount; if (original.m_lObserved != null) { m_lObserved = new HashSet<Predicate>(); foreach (Predicate p in original.m_lObserved) { m_lObserved.Add(p); } } else m_lObserved = null; if (original.m_lHidden != null) { m_lHidden = new HashSet<Predicate>(); foreach (Predicate p in original.m_lHidden) { m_lHidden.Add(p); } } else m_lHidden = null; if (original.AvailableActions != null) { AvailableActions = new List<Action>(); foreach (Action p in original.AvailableActions) { AvailableActions.Add(p); } } else AvailableActions = null; if (bsInitial == null) m_bsInitialBelief = new BeliefState(original.m_bsInitialBelief); else m_bsInitialBelief = bsInitial; if (original.m_sPredecessor != null) m_sPredecessor = new PartiallySpecifiedState(original.m_sPredecessor, m_bsInitialBelief); /*PartiallySpecifiedState tempPredecessorOriginal = original.m_sPredecessor; PartiallySpecifiedState tempPredecessorNew = m_sPredecessor; //m_sPredecessor while (tempPredecessorOriginal != null) { tempPredecessorNew = new PartiallySpecifiedState() }*/ if (original.GeneratingAction != null) GeneratingAction = original.GeneratingAction.Clone(); else GeneratingAction = null; if (original.GeneratingObservation != null) GeneratingObservation = original.GeneratingObservation.Clone(); else GeneratingObservation = null; Problem = original.Problem; if (original.UnderlyingEnvironmentState != null) UnderlyingEnvironmentState = original.UnderlyingEnvironmentState.Clone(); else UnderlyingEnvironmentState = null; //m_bsInitialBelief = original.m_bsInitialBelief; Time = original.Time; if (original.m_cfCNFBelief != null) m_cfCNFBelief = new CompoundFormula(original.m_cfCNFBelief); else m_cfCNFBelief = null; if (original.m_lFailureTag != null) m_lFailureTag = new List<Predicate>(original.m_lFailureTag); else m_lFailureTag = null; if (original.m_lPreviousTags != null) m_lPreviousTags = new List<List<Predicate>>(original.m_lPreviousTags); else m_lPreviousTags = null; if (original.FunctionValues != null) FunctionValues = new Dictionary<string, double>(original.FunctionValues); else FunctionValues = null; }
public void ApplyOffline(string sActionName, out Action a, out Formula fObserve, out PartiallySpecifiedState psTrueState, out PartiallySpecifiedState psFalseState) { psTrueState = null; psFalseState = null; fObserve = null; a = Problem.Domain.GroundActionByName(sActionName.Split(' ')); if (a == null || a is ParametrizedAction) return; ApplyOffline(a, out fObserve, out psTrueState, out psFalseState); }
public PartiallySpecifiedState(PartiallySpecifiedState sPredecessor, Action aGeneratingAction) { ID = STATE_COUNT++; ChildCount = 0; m_bsInitialBelief = new BeliefState(sPredecessor.m_bsInitialBelief); Problem = m_bsInitialBelief.Problem; AvailableActions = new List<Action>(); UnderlyingEnvironmentState = null; if (Problem.Domain.IsSimple) { m_sPredecessor = sPredecessor; } else { m_sPredecessor = new PartiallySpecifiedState(sPredecessor, m_bsInitialBelief); //recursively copies the entire history } GeneratingAction = aGeneratingAction; m_lObserved = new HashSet<Predicate>(sPredecessor.Observed); m_lHidden = new HashSet<Predicate>(sPredecessor.m_lHidden); ForgetPotentialEffects(); FunctionValues = new Dictionary<string, double>(); Time = sPredecessor.Time + 1; foreach (KeyValuePair<string, double> p in sPredecessor.FunctionValues) FunctionValues[p.Key] = p.Value; m_lHistory = new List<string>(sPredecessor.m_lHistory); m_lHistory.Add( GeneratingAction.Name); }
public void ApplyOffline(Action a, out Formula fObserve, out PartiallySpecifiedState psTrueState, out PartiallySpecifiedState psFalseState) { psTrueState = null; psFalseState = null; fObserve = null; a = a.ApplyObserved(m_lObserved); //for removing all generaly known items from the computations. Formula fPreconditions = a.Preconditions; if (fPreconditions != null && !IsApplicable(a)) return; PartiallySpecifiedState bsNew = new PartiallySpecifiedState(this, a); ChildCount = 1; if (a.Effects != null) { if (a.HasConditionalEffects) { List<CompoundFormula> lApplicableConditions = ApplyKnown(a.GetConditions()); bsNew.ApplyKnowledgeLoss(lApplicableConditions); HashSet<Predicate> lAddEffects = new HashSet<Predicate>(), lRemoveEffects = new HashSet<Predicate>(); a.GetApplicableEffects(m_lObserved, lAddEffects, lRemoveEffects, true); //first removing then adding foreach (Predicate p in lRemoveEffects) bsNew.AddEffect(p); foreach (Predicate p in lAddEffects) bsNew.AddEffect(p); //bsNew.UpdateHidden(a, m_lObserved); bsNew.UpdateHidden(); } else { bsNew.AddEffects(a.Effects); } } if (a.Observe != null) { PartiallySpecifiedState bsTrue = bsNew.Clone(); PartiallySpecifiedState bsFalse = bsNew.Clone(); bsTrue.GeneratingObservation = a.Observe; bsFalse.GeneratingObservation = a.Observe.Negate(); ChildCount = 0; if (ConsistentWith(bsTrue.GeneratingObservation, false)) { HashSet<int> hsModifiedTrue = bsTrue.m_bsInitialBelief.ReviseInitialBelief(bsTrue.GeneratingObservation, bsTrue); if (hsModifiedTrue.Count > 0) { bsTrue.PropogateObservedPredicates(); } bsTrue.AddObserved(a.Observe); psTrueState = bsTrue; ChildCount++; } else psTrueState = null; if (ConsistentWith(bsFalse.GeneratingObservation, false)) { HashSet<int> hsModifiedFalse = bsFalse.m_bsInitialBelief.ReviseInitialBelief(bsFalse.GeneratingObservation, bsFalse); if (hsModifiedFalse.Count > 0) { bsFalse.PropogateObservedPredicates(); } bsFalse.AddObserved(a.Observe.Negate()); psFalseState = bsFalse; ChildCount++; } else psFalseState = null; } else psTrueState = bsNew; }
private PartiallySpecifiedState Apply(Action aOrg, out Formula fObserve, bool bPropogateOnly) { //Debug.WriteLine("Executing " + a.Name); fObserve = null; if (aOrg is ParametrizedAction) return null; DateTime dtStart = DateTime.Now; Action a = aOrg.ApplyObserved(m_lObserved); //no need to check pre during propogation - they were already confirmed the first time if (!bPropogateOnly && a.Preconditions != null && !IsApplicable(a)) return null; a.ComputeRegressions(); tsPre += DateTime.Now - dtStart; dtStart = DateTime.Now; State sNew = null; if (!bPropogateOnly && UnderlyingEnvironmentState != null) sNew = UnderlyingEnvironmentState.Apply(a); CompoundFormula cfAndChoices = null; if (!bPropogateOnly && a.ContainsNonDeterministicEffect) { a = a.RemoveNonDeterminism(Time, out cfAndChoices); } PartiallySpecifiedState bsNew = new PartiallySpecifiedState(this, a); if (sNew != null) { bsNew.UnderlyingEnvironmentState = sNew; if (!bPropogateOnly && bsNew.Time != sNew.Time) Debug.WriteLine("BUGBUG"); } if (a.Effects != null) { if (a.HasConditionalEffects) { List<CompoundFormula> lApplicableConditions = ApplyKnown(a.GetConditions()); bsNew.ApplyKnowledgeLoss(lApplicableConditions); HashSet<Predicate> lAddEffects = new HashSet<Predicate>(), lRemoveEffects = new HashSet<Predicate>(); a.GetApplicableEffects(m_lObserved,lAddEffects, lRemoveEffects, true); //first removing then adding foreach (Predicate p in lRemoveEffects) bsNew.AddEffect(p); foreach (Predicate p in lAddEffects) bsNew.AddEffect(p); //bsNew.UpdateHidden(a, m_lObserved); bsNew.UpdateHidden(); } else { bsNew.AddEffects(a.Effects); } } //if(m_sPredecessor != null)//the first one holds all knowns, to avoid propogation from the initial belief // RemoveDuplicateObserved(bsNew.m_lObserved);//if p is true at t+1 and p is true at t, there is no point in maintaining the copy at t tsEffects += DateTime.Now - dtStart; dtStart = DateTime.Now; if (!bPropogateOnly && a.Observe != null) { //first applying the action (effects) and then observing fObserve = bsNew.UnderlyingEnvironmentState.Observe(a.Observe); bsNew.GeneratingObservation = fObserve; bsNew.AddObserved(fObserve); /* if (ReviseInitialBelief(fObserve)) bsNew.PropogateObservedPredicates(); * */ HashSet<int> hsModified = m_bsInitialBelief.ReviseInitialBelief(fObserve, this); if (hsModified.Count > 0) { if (!SDRPlanner.OptimizeMemoryConsumption) bsNew.PropogateObservedPredicates(); } } tsObs += DateTime.Now - dtStart; if (bsNew != null && cfAndChoices != null) m_bsInitialBelief.AddInitialStateFormula(cfAndChoices); if (!bPropogateOnly && bsNew.Time != sNew.Time) Debug.WriteLine("BUGBUG"); return bsNew; }
private void CopyClosedState(PartiallySpecifiedState pssClosed) { Plan = pssClosed.Plan; m_lOfflinePredicatesUnknown = pssClosed.m_lOfflinePredicatesUnknown; m_lOfflinePredicatesKnown = pssClosed.m_lOfflinePredicatesKnown; m_dRelevantVariablesForPrecondition = pssClosed.m_dRelevantVariablesForPrecondition; m_lOfflineObservedPredicates = pssClosed.m_lOfflineObservedPredicates; }
public PartiallySpecifiedState(BeliefState bs) { ID = STATE_COUNT++; Problem = bs.Problem; m_sPredecessor = null; m_lObserved = new HashSet<Predicate>(bs.Observed); AvailableActions = new List<Action>(); UnderlyingEnvironmentState = bs.UnderlyingEnvironmentState; m_bsInitialBelief = bs; ChildCount = 0; m_lHidden = new HashSet<Predicate>(); foreach (CompoundFormula cf in bs.Hidden) { HashSet<Predicate> lCurrent = new HashSet<Predicate>(); cf.GetAllPredicates(lCurrent); foreach (Predicate p in lCurrent) { if (p.Negation) { if (!m_lHidden.Contains(p.Negate())) m_lHidden.Add(p.Negate()); } else if (!m_lHidden.Contains(p)) m_lHidden.Add(p); } } /* as long as there are no non-deterministic effects there is no need to maintain all knowledge foreach (Predicate p in bs.Observed) { if (!Problem.Domain.AlwaysKnown(p)) cfBelief.AddOperand(p); } * */ FunctionValues = new Dictionary<string, double>(); foreach (string sFunction in Problem.Domain.Functions) { FunctionValues[sFunction] = m_bsInitialBelief.FunctionValues[sFunction]; } m_lHistory = new List<string>(); }
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; }
public static List<string> MineSweeperHeuristic(PartiallySpecifiedState pssCurrent, Domain d, Formula fObserve) { int[,] aBoard; aBoard = new int[Size, Size]; List<string> lActions = new List<string>(); List<int> lUnknown = new List<int>(); for (int iX = 0; iX < Size; iX++) { for (int iY = 0; iY < Size; iY++) { GroundedPredicate gp = GetPredicate("opened", iX, iY); if (pssCurrent.Observed.Contains(gp)) { aBoard[iX, iY] = 1;//opened } else { gp = GetPredicate("mine-at", iX, iY); if (pssCurrent.Observed.Contains(gp)) { gp = GetPredicate("flagged", iX, iY); if (pssCurrent.Observed.Contains(gp)) aBoard[iX, iY] = 4;//flagged mine else aBoard[iX, iY] = 2;//unflagged mine } else if(pssCurrent.Observed.Contains(gp.Negate())) aBoard[iX, iY] = 3;//no mine } } } List<int> lCandidates = new List<int>(); for (int iX = 0; iX < Size; iX++) { for (int iY = 0; iY < Size; iY++) { if (aBoard[iX, iY] == 0 || aBoard[iX, iY] == 3) { lCandidates.Add((iX) * 1000 + iY); } else if (aBoard[iX, iY] == 2) lActions.Add("flag p" + iX + "-" + iY); } } if (lCandidates.Count > 0) { int iChosen = lCandidates[RandomGenerator.Next(lCandidates.Count)]; int iChosenX = iChosen / 1000; int iChosenY = iChosen % 1000; lActions.Add("open-cell-" + iChosenX + "-" + iChosenY); //lActions.Add("open-cell p" + iChosenX + "-" + iChosenY); lActions.Add("observe-dead"); for (int i = 0; i < 9; i++) lActions.Add("observe-mine-count p" + iChosenX + "-" + iChosenY + " v" + i); Shootings++; } /* else if (lUnknown.Count > 0) { int iChosen = lUnknown[RandomGenerator.Next(lUnknown.Count)]; int iChosenX = iChosen / 1000; int iChosenY = iChosen % 1000; lActions.Add("shoot p-" + iChosenX + " p-" + iChosenY); Shootings++; } */ return lActions; }
public HashSet<int> ReviseInitialBelief(Formula fObserve, PartiallySpecifiedState pssLast) { DateTime dtBefore = DateTime.Now; Stack<PartiallySpecifiedState> sTrace = new Stack<PartiallySpecifiedState>(); Stack<List<Formula>> sForumalsTrace = new Stack<List<Formula>>(); PartiallySpecifiedState pssCurrent = pssLast, pssSuccessor = null; HashSet<int> hsModifiedClauses = new HashSet<int>(); //Formula fToRegress = fObserve, fRegressed = null; bool bTrueRegression = false; int cSteps = 0; count_revisions++; List<Formula> lCurrentFormulas = new List<Formula>(); List<Formula> lRegressedFormulas = new List<Formula>(); lCurrentFormulas.Add(fObserve); //TimeSpan ts1 = new TimeSpan(0), ts2 = new TimeSpan(0); //DateTime dtStart = DateTime.Now; while (pssCurrent.Predecessor != null) { sTrace.Push(pssCurrent); sForumalsTrace.Push(lCurrentFormulas); lRegressedFormulas = new List<Formula>(); HashSet<Predicate> hsNew = new HashSet<Predicate>(); foreach (Formula fCurrent in lCurrentFormulas) { if (fCurrent.IsTrue(pssCurrent.Observed)) continue;//used to be break but I think that if we got here then there is no point in continuing... //is false doesn't properly work here //Debug.Assert(fCurrent.IsFalse(pssCurrent.Observed), "Rgression of an observation returned false"); //pssCurrent.GeneratingAction.ClearConditionsChoices(); //pssCurrent.GeneratingAction.RemoveImpossibleOptions(pssCurrent.Observed); Need to this after the regression (below) //DateTime dt = DateTime.Now; Formula fRegressed = pssCurrent.RegressObservation(fCurrent); //ts1 += DateTime.Now - dt; if (fRegressed is CompoundFormula) { CompoundFormula cf = (CompoundFormula)fRegressed; if (cf.Operator != "and") { lRegressedFormulas.Add(fRegressed); } else { foreach (Formula f in cf.Operands) lRegressedFormulas.Add(f); } } else lRegressedFormulas.Add(fRegressed); //dt = DateTime.Now; //must be after the regression so as not to make everything already known if (!Problem.Domain.IsSimple || !SDRPlanner.OptimizeMemoryConsumption) hsNew.UnionWith(pssCurrent.AddObserved(fCurrent)); //ts2 += DateTime.Now - dt; //pssCurrent.AddObserved(fToRegress); //Not sure that this is valid! if (!fRegressed.Equals(fCurrent)) //if (bTrueRegression || !fRegressed.Equals(fToRegress)) bTrueRegression = true; } if (hsNew.Count > 0 && pssSuccessor != null) { hsNew = pssSuccessor.PropogateObservedPredicates(hsNew); /* for (int i = 0; i < sTrace.Count; i++) { PartiallySpecifiedState pssUpdate = sTrace.ElementAt(i); hsNew = pssUpdate.PropogateObservedPredicates(hsNew); if (hsNew.Count == 0) break; } * */ } pssSuccessor = pssCurrent; pssCurrent = pssCurrent.Predecessor; cSteps++; lCurrentFormulas = lRegressedFormulas; } Formula fFinal = null; if (lCurrentFormulas.Count == 0) return hsModifiedClauses; if (lCurrentFormulas.Count == 1) { fFinal = lCurrentFormulas[0].Reduce(Observed); fFinal = fFinal.ToCNF(); } else { CompoundFormula cf = new CompoundFormula("and"); foreach (Formula f in lCurrentFormulas) { Formula fReduced = f.Reduce(Observed).Simplify(); Formula fCNF = null; if (fReduced is CompoundFormula) fCNF = ((CompoundFormula)fReduced).ToCNF(); else fCNF = fReduced; cf.AddOperand(fCNF); } fFinal = cf; } //Debug.WriteLine("Total time in regressobs " + ts1.TotalSeconds + " propogate " + ts2.TotalSeconds + // " all " + (DateTime.Now - dtStart).TotalSeconds + " size " + fFinal.Size); if (fFinal.IsTrue(null)) return hsModifiedClauses; DateTime dtAfterRegression = DateTime.Now; DateTime dtAfterReasoning = DateTime.Now; //Seems likely but I am unsure: if there was no real regression, then learned things can be applied to all states as is HashSet<Predicate> lLearned = null; if (BeliefState.UseEfficientFormulas) lLearned = AddReasoningFormulaEfficient(fFinal); else lLearned = AddReasoningFormula(fFinal, hsModifiedClauses); HashSet<Predicate> lOriginalLearned = new HashSet<Predicate>(lLearned); if (lLearned.Count > 0) { //HashSet<Predicate> lLearned = pssCurrent.ApplyReasoning(); not needed since we got the learned predicates from the belief update if (!Problem.Domain.IsSimple || !SDRPlanner.ComputeCompletePlanTree) pssCurrent.AddObserved(lLearned); dtAfterReasoning = DateTime.Now; if (bTrueRegression) { //while (bUpdate && sTrace.Count > 0) while (sTrace.Count > 0 && lLearned.Count > 0) { pssCurrent = sTrace.Pop(); //bUpdate = pssCurrent.PropogateObservedPredicates(); lLearned = pssCurrent.PropogateObservedPredicates(lLearned); } if (SDRPlanner.OptimizeMemoryConsumption && lLearned.Count > 0) { pssLast.AddObserved(lLearned); } } else { if (!SDRPlanner.OptimizeMemoryConsumption) { while (sTrace.Count > 0) { pssCurrent = sTrace.Pop(); pssCurrent.AddObserved(lLearned); } } else pssLast.AddObserved(lLearned); } } /* Console.WriteLine("Time for belief update: " + (DateTime.Now - dtBefore).TotalSeconds + " regression " + (dtAfterRegression - dtBefore).TotalSeconds + " reasoning " + (dtAfterReasoning - dtAfterRegression).TotalSeconds + " update " + (DateTime.Now - dtAfterReasoning).TotalSeconds); */ return hsModifiedClauses; }
public PartiallySpecifiedState GetPartiallySpecifiedState() { PartiallySpecifiedState pss = new PartiallySpecifiedState(this); if(SDRPlanner.EnforceCNF) m_cfCNFHiddenState = (CompoundFormula)m_cfCNFHiddenState.ToCNF(); return pss; }