0.10.0

• Significant breaking changes. Essentially a minor redesign:
  • Created IState interface, in which the Elements property is IQueryable<Predicate> - ultimately to facilitate states that are large enough to require a separate backing store.
  • Added HashSetState, which is an implementation of IState that just stores its elements in memory.
  • Removed the Domain class. It was not particularly valuable, and the duplication of e.g. Constants between Problem and Domain makes allowing for a separate backing store difficult. A flatter model makes everything a bit simpler. Action schemas are now directly part of Problem, and Constants and Predicates now don't have properties for them - instead being derived from IState and Actions repsectively where needed. It might turn out that we need to add them back (to Problem) to allow particular implementations for them, but probably not.
• Dependency updates
• Minor fix to AirCargo example domain. Due to some commenting out, I've obviously spotted this before - not sure why I didn't sort it.
• Minor bug fix: The identifier for persistence actions in planning graphs is now guaranteed to be unique.
• Include the RecognitionException (if any) as the inner exception of exceptions thrown from the PDDL parser.
• Package description update

0.9.0

Breaking changes:

• Renamed Planning.Search namespace to Planning.StateAndGoalSpace. I'm not saying I'll ever look at e.g. plan-space stuff, but if I do, I'll want to be able to do it without making the namespaces awkward.
• Renamed PlanningGraphLevel to PlanningGraphPropositionLevel, for clarity and consistency.

Non-breaking changes:

• Added a PDDL parser - SCFirstOrderLogic.ProblemCreation.PddlParser. Quite limited for the mo. A demo has been added to the docs site.
• Bug fix to DomainInspector.GetMappingFromSchema.
• Made the state- and goal-space types (graph-theoretical nodes and edges) in the StateAndGoalSpace namespace public.
• Updated dependencies
• As ever, continued comment and XML doc improvements
• Added "graphplan" as a package tag, updated package readme to mention graphplan

0.8.0

Breaking changes:

• Renamed StateSpaceSearch to StateSpaceAStarPlanner and GoalSpaceSearch to GoalSpaceAStarPlanner - for clarity.
• The various IPlanningTask implementations are no longer public inner types of their respective planners.
• Planning.Search.IStrategy renamed to ICostStrategy, for clarity. Considered "ICostProvider", but decided that perhaps implies that it provides only the costs themselves, and not also cost estimates. Also some renaming for consistency in the face of this change:
  • The Planning.Search.Strategies namespace renamed to CostStrategies
  • DelegateStrategy renamed to DelegateCostStrategy
• PlanningGraph's API has changed significantly - mostly for robustness. It was far too easy to write fragile code against it before - because whether you'd called GetLevel enough times for it to level off was something you needed to consider. No longer. Also lifted the public inner types (Level, PropositionNode, ActionNode) out of PlanningGraph. There's no need for them to be inner types (doing this unecessarily is a bad habit of mine..).

Non-breaking changes:

• A number of significant PlanningGraph fixes.
• Added GraphPlanPlanner and GraphPlanPlanningTask. In so doing, realised that "Artifical Intelligence: A Modern Approach" really isn't a good resource for GraphPlan - leaves so much out that it's downright misleading in places. This implementation is more influenced by "Automated Planning: Theory and Practice".
• Made all ...PlanningTask ctors public. There's no reason consumers shouldn't be allowed to instantiate these directly, as opposed to going via IPlanner - so might as well empower people.
• Plan.Steps prop changed from an IReadOnlyCollection to an ImmutableList (should be non-breaking, since ImmutableList implements IReadOnlyCollection).
• Added TemplatePlanningTask - just a handy base class for planning tasks.
• Some performance improvements to transformations, by confronting my LINQ addiction.
• As ever, continuous improvements to XML docs, as well as various comment improvements for those that are debugging.
• Fixed self-closing para tags in XML documentation - which aren't valid (and, while fine for VS, don't get rendered "correctly" in FuGet explorer).
• Package description typo fix.
• Some relatively unimportant dependency updates

0.7.0

Breaking changes:

• Breaking changes to "search" planners. Folded action cost calculation into the same interface as the one that contains EstimateCost - that is, IHeuristic. Renamed it to IStrategy since its no longer just about the heuristic. StateSpaceSearch and GoalSpaceSearch are now a little less ugly as a result. And of course this is a sensible grouping of functionality - because estimates should obviously be affected by costs..
• Following on from the above, the namespace in which all of the package-provided strategies reside has been renamed from Heuristics to Strategies.

Non-breaking changes:

• PlanningGraph competing needs mutex creation fix (mutex will now be noted if preconditions are mutex because their causes are - not just if they are negations).
• State class robustness improvement - will now throw an exception for non-ground terms from anyof the public ctors, not just the Sentence-accepting one.
• Performance improvement for State, Goal and Effect equality.
• Package now requires license acceptance. Probably going to start doing this for all my packages now - it just seems sensible.

Also, behind the scenes, getting there with GraphPlan - have my head around no-goods now I think - just need to implement them so that it actually terminates when a plan can't be constructed.

0.6.1

Some fixes:

• PlanningGraph fixes:
  • Actions from each level now formulated, well, correctly.
  • PlanningGraph.Level now includes a reference back to the Graph that it resides in (to allow for search nodes in GraphPlan to be a little smaller than they would otherwise be).
  • Level Index property corrected so that it is no longer off by one.
  • Mutexes representing action interference are now created correctly (weren't checking in both directions..)
• Problems now include Domain constants, as they should always have done.

Also updated package project URL to point at docs website.

0.6.0

• Minor model changes:
  • Refactoring for clarity: in Goal, PositivePredicates renamed to RequiredPredicates and NegativePredicates renamed to ForbiddenPredicates.
  • Some minor tweaks to reduce GC pressure (use a given ImmutableHashSet in a few places where we were needlessly creating a copy)
  • Refactoring for maintainability: Moved implementation of action relevancy from effect into goal - so that relevancy and regression logic are in the same place.
• Planning.StateSpaceSearch namespace renamed to Planning.Search.
• BackwardStateSpaceSearch renamed to GoalSpaceSearch, because that's what it is.
• ForwardStateSpaceSearch renamed to StateSpaceSearch
• Planning "utilities" changes:
  • Moved the "Inspector" types in the Planning namespace into a "Utilities" sub-namespace.
  • Added async versions of InvariantInspector's methods - as the IKnowledgeBase methods that they call are.
  • Minor performance tweak in InvariantInspector. Pre-populate result cache with empty goal, instead of checking for it separately every time.
  • Undid a frankly bizarre design decision in InvariantInspector: IKnowledgeBase ctor param is no longer optional - as the class can't do anything without it.
• Problem manipulation changes:
  • Re-added support for functions to problem manipulation types. Was overzealous of me to remove them. If planning algorithms can't handle functions, the place to complain is in the algorithms themselves. I have however re-ordered some switch statements though - to shuffle functions to the end..
• Added IPlanningTask - IPlanners now use this instead of Task<Plan>. Added SteppablePlanningTask implementation - used by StateSpaceSearch and GoalSpaceSearch
• GraphPlan changes:
  • PlanningGraph tweaks: LevelledOff renamed to IsLevelledOf (conventional for bool-valued props), and renamed GetSetLevel to GetLevelCost - yes, "set level" is the terminology, but GetSet.. is a rather confusing name, and note how calling this method with a single-entry enum will always give the same result as GetLevelCost(Literal) - so it makes sense as an overload.
  • Made GraphPlan class internal. Its not fully implemented yet - making it public was in error.
• Upgraded SCGraphTheory.Search dependency to use some new stuff from it
• Type and member doc improvements
• Some static analysis fixes

0.5.0

• Core model changes:
  • Changed props that were ReadOnlyCollections to ImmutableHashSets - for consistency, and because modelling as immutable sets makes more sense anyway
  • Added GetSatisfyingSubstitutions method to State class. Further changes in this area seem likely.
  • Added Predicates and Constants properties to Domain class - needed for PlanningGraph
• Changes in the Planning namespace
  • Added 'lifted' (i.e. variable-preserving) relevant action lookup methods to DomainInspector
  • Added CancellationToken parameter to IPlanner.CreatePlanAsync
  • Added a CreatePlan extension method for IPlanner
• Changes in the Planning.StateSpaceSearch namespace:
  • Created an interface for heuristics (IHeuristic), instead of passing lots of delegates around.
  • IgnorePreconditionsGreedySetCover heuristic changes:
    • Fixed error that meant -1 (instead of float.PositiveInfinity) was returned when no relevant effects are found
    • Problem-valued ctor parameter replaced with Domain-valued one - only needs the domain
    • Performance fix - a couple of instances of ...Count() == 0 replaced with !...Any()
  • ElementDifferenceCount heuristic renamed to UnsatisfiedGoalCount
• Changes in the Planning.GraphPlan namespace:
  • Added a basic PlanningGraph implementation
• Upgraded SCGraphTheory.Search and SCFirstOrderLogic dependencies, facilitating:
  • Tweaks to state space search implementation: they now use a new method in SCGraphTheory.Search for asynchronously executing a search to completion, instead of explicitly creating their own Task instance.
  • Dealing with the jankiness in the Visitor classes in ProblemManipulation namespace - where some visit state was passed in by reference and others not.
• Lots of general refactoring, including but not limited to:
  • Refactoring of types in ProblemManipulation namespace. Includes removal of some overzealous interfaces (that are never consumed) and the addition of a RecursiveActionTransformation class
  • Extracted invariant checking logic from GoalInvariantCheck heuristic to a new InvariantInspector class.
  • Renamed some methods in Domain/ProblemInspector for brevity.
  • Modified ProblemInspector.GetAllPossibleSubstitutions so that it accepts a Problem instead of an enumerable of constants. In prep for perhaps making this class instantiable (thus raising the possibility of caching etc).
• Lots of XML docs, comments and static analysis fixes
• Switched to Apache 2.0 license

0.4.0

Breaking changes:

• GetMappingFromSchema method moved from Domain class to a new DomainInspector class in the Planning namespace

Non-breaking changes:

• State space searches now handle failure a little more gracefully - they'll now throw an informative ArgumentException stating that the problem is unsolvable, instead of an unguessable one.
• Tweaked / fixed IgnorePreconditionsGreedySetCover heuristic to the point that it might be vaguely useful
• Added a GoalInvariantCheck heuristic - a decorator heuristic that checks whether the goal violates any known invariants before invoking the inner heuristic. If any invariants are violated, returns float.PositiveInfinity. Intended to be of use for early pruning of unreachable goals when backward searching.
• Updated SCGraphTheory.Search dependency to a version that'll take particular note if an A* heuristic gives an infinite cost for something.
• Updated SCFirstOrderLogic dependency
• Comments and docs: including removal of some TODOs that aren't worth doing in the near future or at all.

0.3.0

Breaking changes:

• Refactored the GetApplicable/RelevantActions methods out of the Problem class and into a new ProblemInspector class in the Planning namespace. There may ultimately be value in planners making use of strategy objects to do this kind of thing - but for now at least, I just wanted to get them out of the model.

Other changes:

• Various type and member documentation improvements.
• Added GetApplicable/RelevantActionSchemaAndSubstitution methods to ProblemInspector. These return both the relevant action schema and the substitution to apply, rather than just the applicable or relevant action.
• State space search now allows actions to have associated costs.

0.2.1

Changed the package icon, because it was rubbish. Blocks world!