Assignment Chef icon Assignment Chef
All English tutorials

Programming lesson

Mastering Logic Programming with ASP: A Guide to CMT304 Programming Paradigms

Learn how to approach the CMT304 Logic Programming assignment using Answer Set Programming (ASP). This tutorial covers encoding constraints, guess-and-test methodology, and optimization for patent review allocation.

CMT304 programming paradigms logic programming assignment ASP answer set programming patent review problem guess and test methodology ASP constraints optimization declarative programming tutorial clingo solver example CMT304 task 1.1 solution expert assignment maximization workload balance constraint AI patent matching 2026 programming paradigms portfolio CMT304 logic programming help ASP for combinatorial problems referee assignment logic

Introduction to Logic Programming and ASP for CMT304

Logic programming is a paradigm where computation is driven by logical deduction rather than step-by-step instructions. In the CMT304 Programming Paradigms module, you'll explore Answer Set Programming (ASP), a declarative approach ideal for solving combinatorial problems like the patent review assignment. This tutorial breaks down the key concepts using the assignment's scenario: assigning patent requests to referees based on expertise bids. With the rise of AI-driven patent analysis in 2026, understanding ASP is more relevant than ever.

Understanding the Patent Review Problem

The problem involves a set of referees, each bidding on patent requests with expertise levels: Expert, Knowledgeable, Familiar, or Inexpert. Your task is to write an ASP program that assigns each request to exactly one referee, satisfying constraints: workloads differ by at most m, no referee reviews more than k Familiar submissions, minimize Inexpert assignments, and maximize Expert assignments. Parameters n, m, and k are given at runtime. This mirrors real-world patent office workflows, where AI tools now assist in matching reviewers to inventions.

Guess-and-Test Methodology in ASP

ASP programs follow a guess-and-test pattern: first, generate candidate solutions (guesses), then eliminate those violating constraints (test). For our assignment, the guess part creates all possible assignments of referees to requests. The test part enforces the constraints using rules and integrity constraints. This declarative style lets you focus on what the solution should satisfy, not how to compute it.

Encoding the Guess: Choice Rules

In ASP, you use choice rules to generate assignments. For example:

{assign(Ref, Req)} :- bid(Ref, Req, _).

This rule says: for each bid, we may choose to assign that referee to that request. The underscore ignores the expertise level at this stage. However, we need exactly one referee per request. That's a constraint we'll add later.

Encoding the Test: Constraints

Constraints are rules that must hold. For example, each request must be assigned to exactly one referee:

:- request(Req), not #count{Ref: assign(Ref, Req)} = 1.

This integrity constraint eliminates any assignment set where a request does not have exactly one referee. Similarly, workload balance is enforced by:

:- #count{Req: assign(Ref, Req)} = W1, #count{Req: assign(Ref2, Req)} = W2, |W1-W2| > m.

This ensures no two referees' workloads differ by more than m.

Optimizing for Expert and Inexpert Assignments

The problem asks to maximize Expert assignments and minimize Inexpert ones. In ASP, optimization is done with #maximize and #minimize statements. For example:

#maximize {1, assign(Ref, Req) : bid(Ref, Req, expert)}.

This maximizes the count of Expert assignments. Similarly, minimize Inexpert ones. These directives guide the solver to prefer solutions that meet the objectives.

Putting It All Together: Complete Program Structure

Your problem_encoding.lp should include:

  • Input predicates: bid(ref, req, exp) and parameters n, m, k.
  • Derived predicates: request(Req) from bids.
  • Choice rule: generate assignments.
  • Constraints: exactly one referee per request, workload balance, Familiar limit.
  • Optimization: maximize Expert, minimize Inexpert.
  • Output: assign(ref, req).

Here's a skeleton:

% Define requests request(Req) :- bid(_, Req, _). % Guess {assign(Ref, Req)} :- bid(Ref, Req, _). % Exactly one referee per request :- request(Req), #count{Ref: assign(Ref, Req)} != 1. % Workload balance :- referee(Ref1), referee(Ref2), Ref1 != Ref2, #count{Req: assign(Ref1, Req)} = W1, #count{Req: assign(Ref2, Req)} = W2, |W1-W2| > m. % Familiar limit :- referee(Ref), #count{Req: assign(Ref, Req), bid(Ref, Req, familiar)} > k. % Maximize Expert #maximize {1, assign(Ref, Req) : bid(Ref, Req, expert)}. % Minimize Inexpert #minimize {1, assign(Ref, Req) : bid(Ref, Req, inexpert)}.

Note: You'll need to define referee(Ref) from bids. Also ensure n is used if needed (e.g., number of referees).

Testing and Debugging Your ASP Program

Use an ASP solver like clingo. Run with:

clingo problem_encoding.lp --const n=3 --const m=1 --const k=2

Provide sample bids as facts in a separate file. Check that all constraints are met. Common pitfalls: forgetting to declare parameters, incorrect aggregation syntax, or missing predicates.

Real-World Relevance and Trends

In 2026, patent offices worldwide use AI to automate prior art searches and reviewer assignment. The logic programming approach in ASP aligns with explainable AI, as solutions are derived from logical rules. This assignment mirrors the shift toward declarative programming in high-stakes applications. By mastering ASP, you gain skills applicable to scheduling, resource allocation, and even game AI (e.g., Sudoku solvers).

Conclusion

Logic programming with ASP offers a powerful way to solve constraint satisfaction problems. For the CMT304 assignment, focus on clear encoding of guesses and tests. Document each rule's purpose, as required in Task 1.2. With practice, you'll appreciate how declarative programming simplifies complex combinatorial logic. Good luck!