Скачать или смотреть How to Stop Recursion in Prolog Once the Desired Value is Returned

Discover effective strategies to stop recursion in Prolog by implementing a two-predicate approach for spouse relationships. This guide guides you through practical solutions for your Prolog coding challenges.
---
This video is based on the question https://stackoverflow.com/q/63317159/ asked by the user 'R96R' ( https://stackoverflow.com/u/10109201/ ) and on the answer https://stackoverflow.com/a/63317196/ provided by the user 'willeM_ Van Onsem' ( https://stackoverflow.com/u/67579/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: How to stop the recursion in prolog, once the desired value is returned?

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
How to Stop Recursion in Prolog Once the Desired Value is Returned

Prolog is a powerful programming language widely used for solving problems related to artificial intelligence and computational linguistics. However, when dealing with recursive queries, you may encounter the annoying issue of endless recursion. If you've ever been in a situation where your query keeps returning the same value without stopping, you're not alone.

In this guide, we’ll explore how to effectively manage recursion in Prolog, particularly in the context of establishing relationships like spouses.

The Problem: Endless Recursion

Let’s take a look at a specific scenario. Suppose you have defined a Prolog predicate that states:

[[See Video to Reveal this Text or Code Snippet]]

You also want to establish that if Eddard is a spouse of Catelyn, then Catelyn is also a spouse of Eddard. You add the rule:

[[See Video to Reveal this Text or Code Snippet]]

When you query for:

[[See Video to Reveal this Text or Code Snippet]]

You might find that Prolog enters an endless loop, continuously returning catelyn_stark.

What is Happening?

The issue arises from the recursive nature of your definitions. When Prolog checks for spouse(eddard_stark, X), it finds spouse(eddard_stark, catelyn_stark), but due to the nature of the rule provided, it keeps flipping the parameters and never stops – falling into an infinite loop.

The Solution: Using Two Predicates

To resolve this endless recursion issue, consider employing two distinct predicates. The first will contain the actual relationships, while the second will manage the directionality of your queries. Here’s how to implement it step by step:

Step 1: Define the Spouse Relationships

Create a predicate that holds the relationship data. This could be named spouse_data/2:

[[See Video to Reveal this Text or Code Snippet]]

Step 2: Create a Directional Spouse Predicate

Now create another predicate, spouse/2, which will manage how Prolog queries the relationships:

[[See Video to Reveal this Text or Code Snippet]]

Step 3: Query the Predicate

Now, when you query for:

[[See Video to Reveal this Text or Code Snippet]]

Prolog will check both directions without succumbing to endless recursion. It will now return X = catelyn_stark and then stop, as there are no further valid solutions.

Alternative Solutions

While the two-predicate method is effective, there are always alternate solutions you could consider depending on the complexity of your data:

Base Cases: Ensure that proper base cases are defined in your predicates to prevent unwarranted recursion.

Cut Operator: Use the cut operator (!) strategically to limit the search space within your recursive queries, effectively controlling when Prolog can backtrack.

Helper Predicates: Sometimes, using helper predicates to store intermediate results can also limit recursive calls.

Conclusion

Using a structured approach with separate predicates for your data and queries can effectively eliminate the problem of endless recursion in Prolog. This not only makes your Prolog program more efficient but also easier to read and maintain.

By understanding how to manage recursion strategically, you'll become a more adept Prolog programmer. Happy coding!