ASP Logic Programming Tutorial: Patent Assignment Problem

Introduction to Logic Programming with ASP

Logic programming, a key paradigm in the CMT304 Programming Paradigms module, offers a declarative approach to solving complex combinatorial problems. Unlike imperative languages, you describe what the solution should satisfy, not how to compute it. Answer Set Programming (ASP) is a modern incarnation of logic programming, widely used in AI, scheduling, and resource allocation. In this tutorial, we'll tackle a realistic patent assignment problem that mirrors real-world matching tasks, similar to how AI-driven platforms match freelancers to projects or players to teams in esports tournaments.

Understanding the Patent Assignment Problem

Imagine a patent office where referees declare their expertise for each patent request. The goal is to assign each request to exactly one referee, respecting workload balance, limiting familiar reviews, maximizing expert assignments, and minimizing inexpert ones. This is a classic constraint satisfaction problem (CSP) that ASP handles elegantly.

Key parameters:

n: number of referees
m: maximum allowed workload difference between any two referees
k: maximum number of 'Familiar' reviews per referee

Input is a set of bid(ref, req, exp) facts, where exp is one of expert, knowledgeable, familiar, or inexpert. Output is assign(ref, req) pairs.

Setting Up Your ASP Environment

We'll use clingo (version 5.5 or later) as the ASP solver. Install it via pip install clingo or download from potassco.org. Your solution file must be named problem_encoding.lp.

Step 1: Representing the Problem in ASP

First, define the domain: which referees and requests exist?

referee(R) :- bid(R, _, _).
request(R) :- bid(_, R, _).

These rules derive all referees and requests from the input bids.

Step 2: The Guess – Assigning Requests to Referees

We use a choice rule to guess assignments:

{ assign(R, Req) : bid(R, Req, _) } = 1 :- request(Req).

This says: for each request, choose exactly one referee from those who placed a bid. The =1 ensures each request is assigned to exactly one referee.

Step 3: The Test – Enforcing Constraints

Now we add constraints to filter valid assignments.

Workload Balance

Let workload(R) = #count{Req : assign(R, Req)}. The difference between max and min workload must be ≤ m. We enforce:

:- maxWorkload - minWorkload > m.
maxWorkload = #max{W : workload(R,W)}.
minWorkload = #min{W : workload(R,W)}.
workload(R, W) :- W = #count{Req : assign(R, Req)}, referee(R).

This uses aggregate functions to compute workloads and then discards solutions where the gap exceeds m.

Limit Familiar Reviews

Count how many familiar bids each referee is assigned:

familiarCount(R, C) :- C = #count{Req : assign(R, Req), bid(R, Req, familiar)}, referee(R).
:- familiarCount(R, C), C > k.

This ensures no referee reviews more than k familiar submissions.

Minimize Inexpert Assignments

We want to minimize assignments where the referee declared inexpert. Use a weak constraint:

:~ assign(R, Req), bid(R, Req, inexpert). [1@1, R, Req]

The [1@1] gives a penalty of 1 at priority 1. The solver minimizes total penalty.

Maximize Expert Assignments

Similarly, we maximize expert assignments:

:~ assign(R, Req), not bid(R, Req, expert). [1@2, R, Req]

This penalizes non-expert assignments at a higher priority (2) so the solver first maximizes experts, then minimizes inexpert.

Step 4: Complete Program and Usage

Combine all rules. Your problem_encoding.lp should look like:

% Domain
referee(R) :- bid(R, _, _).
request(R) :- bid(_, R, _).

% Guess
{ assign(R, Req) : bid(R, Req, _) } = 1 :- request(Req).

% Workload balance
workload(R, W) :- W = #count{Req : assign(R, Req)}, referee(R).
maxWorkload = #max{W : workload(R,W)}.
minWorkload = #min{W : workload(R,W)}.
:- maxWorkload - minWorkload > m.

% Familiar limit
familiarCount(R, C) :- C = #count{Req : assign(R, Req), bid(R, Req, familiar)}, referee(R).
:- familiarCount(R, C), C > k.

% Minimize inexpert
:~ assign(R, Req), bid(R, Req, inexpert). [1@1, R, Req]

% Maximize expert
:~ assign(R, Req), not bid(R, Req, expert). [1@2, R, Req]

Run with: clingo problem_encoding.lp --const n=3 --const m=1 --const k=2 and provide bid/3 facts in the same file or via stdin.

Optimization Tips for Your CMT304 Submission

To achieve high distinction, consider:

Use heuristics to guide search: #heuristic assign(R,Req) : bid(R,Req,expert). [1, true]
Add symmetry breaking constraints to reduce search space.
Document each rule clearly, explaining how the body is evaluated and what output it generates.
Discuss the guess-and-test methodology in your report: the choice rule guesses, constraints test, and weak constraints optimize.

Real-World Connections

This problem resembles matching algorithms used in gig economy apps like Uber or Upwork, where tasks are assigned to workers based on skills and availability. In AI research, similar ASP encodings are used for robot task planning and scheduling. Understanding ASP gives you a powerful tool for solving constraint satisfaction problems in many domains.

Conclusion

By following this tutorial, you've built a complete ASP solution for the patent assignment problem. Remember to test with various inputs and parameters to ensure your program finds all solutions. Good luck with your CMT304 assessment!