A* search is widely used for pathfinding, planning, and many optimisation problems because it can be both efficient and correct. However, A* only guarantees an optimal solution under specific conditions on the heuristic function. If you are learning search formally—whether through self-study, project work, or an artificial intelligence course in Delhi—understanding admissibility and related criteria is essential for using A* safely in real systems.
A* in One Minute: What the Heuristic Controls
A* expands states in order of the evaluation function:
- f(n) = g(n) + h(n)
Where:
- g(n) is the known cost from the start to node n.
- h(n) is the heuristic estimate of the remaining cost from n to a goal.
A* behaves like Dijkstra’s algorithm when h(n) = 0, and becomes more “goal-directed” as h(n) becomes more informative. The catch is that if h(n) is too optimistic or too aggressive in the wrong way, A* can return a suboptimal path.
Admissibility: The Core Optimality Condition
A heuristic h is called admissible if it never overestimates the true remaining cost to the goal.
Formal condition
Let h*(n) be the true optimal cost from n to a goal. Then h is admissible if, for every node n:
- 0 ≤ h(n) ≤ h*(n)
This single inequality is the most important admissibility criterion. It ensures A* will not “skip over” the optimal path because the heuristic made it look too expensive.
Why it guarantees optimality (intuition)
If h never overestimates, then f(n) = g(n) + h(n) is always a lower bound on the cost of any solution that goes through n. A* expands nodes in increasing order of these lower bounds. When A* selects a goal node for expansion, no other frontier node can possibly lead to a cheaper solution, so the found solution must be optimal.
This is why admissibility is often presented as the formal safety rule behind A* in many curricula, including an artificial intelligence course in Delhi that covers classical search.
Consistency (Monotonicity): The Stronger Criterion for Graph Search
Admissibility alone is enough for optimality in tree search (where you do not merge repeated states). In practical implementations, A* is usually run as graph search with a closed set to avoid re-expanding the same state. For that common setup, you typically want consistency, also called monotonicity.
Formal condition
A heuristic h is consistent if, for every edge (n → n′) with step cost c(n, n′):
- h(n) ≤ c(n, n′) + h(n′)
and also h(goal) = 0.
This resembles a triangle inequality: the estimated distance from n to the goal should be no more than “one step to n′ plus the estimate from n′”.
Why consistency matters
Consistency implies that the f-value along any path is non-decreasing:
- f(n′) = g(n′) + h(n′) ≥ g(n) + c(n, n′) + h(n′) ≥ g(n) + h(n) = f(n)
So once A* expands a node, the best path to it has effectively been found. This prevents the algorithm from needing to “reopen” closed nodes and keeps the usual closed-set A* both efficient and optimal.
A useful fact: Every consistent heuristic is admissible, but the reverse is not always true.
Designing Admissible Heuristics in Practice
In real applications, you rarely know h*(n). Instead, you construct h(n) so it is guaranteed to be a lower bound.
1) Use a relaxed version of the problem
Remove constraints so the problem becomes easier. The optimal cost in the relaxed problem cannot exceed the true optimal cost, so it provides an admissible heuristic.
Example: In routing, ignoring one-way restrictions or traffic constraints gives a “best possible” optimistic estimate.
2) Use problem geometry or metric lower bounds
In a grid, Manhattan distance is admissible when moves are 4-directional with uniform step costs. Euclidean distance can be admissible when movement cost reflects straight-line travel.
3) Combine admissible heuristics safely
If h1 and h2 are admissible, then:
- h(n) = max(h1(n), h2(n)) is also admissible (and usually more informative).
But h1(n) + h2(n) is not guaranteed to be admissible unless you can prove the sub-costs are independent and do not double-count.
These design patterns come up frequently in hands-on teaching, including an artificial intelligence course in Delhi focused on search and planning.
Common Ways Optimality Breaks (and How to Avoid It)
- Overestimation: If h(n) > h*(n) for any n, A* can return a suboptimal solution.
- Inconsistent heuristics with a closed list: Even if h is admissible, inconsistency may require reopening nodes. If your implementation never reopens, optimality can be lost.
- Changing or negative step costs: Standard A* assumptions rely on non-negative edge costs. If costs can be negative, you need different methods or strong constraints.
- Using Weighted A*: Variants like f(n)=g(n)+w·h(n) with w>1 are intentionally not admissible and trade optimality for speed.
Conclusion
To guarantee that A* finds an optimal solution, the heuristic must satisfy clear formal conditions. Admissibility (0 ≤ h(n) ≤ h*(n)) ensures the heuristic never overestimates the remaining cost, which is enough for optimality in tree-based A*. For the common closed-set graph search version, consistency (h(n) ≤ c(n, n′) + h(n′)) is the stronger, practical criterion that preserves optimality without repeated re-expansions. If you apply these rules carefully—whether in production systems or while studying in an artificial intelligence course in Delhi—you can use A* with confidence that “fast” does not come at the expense of “correct.”