url('https://fonts.googleapis.com/css2?family=Raleway:ital,wght@0,100..900;1,100..900&family=Source+Serif+4:ital,opsz,wght@0,8..60,200..900;1,8..60,200..900&display=swap');

(min-width: 768px) {
  .article.article-md h2 {
    font-size: 24px;
  }
}

(min-width: 1024px) {
  .article.article-md h2 {
    font-size: 28px;
  }
    .heading-button {
    width: 50px;
    height: 50px;
  }
  .heading-button-arrow {
    font-size: 28px;
    padding: 12px 8px
  }
}

(max-width: 768px) {
  [data-root-node="true"] {
    --margin-left: 0px !important;
    --margin-right: 0px !important;
  }
  .contained { 
    padding: 0px 16px;
  }

  [data-tid="h"] {
    margin-left: var(--margin-left);
    margin-right: var(--margin-right);
  }
  .auto-column-container {
    column-count: 1;
  }
  .pullquote, .pullquote.left, .pullquote.right{
    float: none;
    width: 100%;
    text-align: center;
    margin-left: 0;
    margin-right: 0;
  }

  .footer-content { 
    grid-template-columns: repeat(3, 1fr);
  }

  .footer-about {
    grid-column: 1 / span 3;
  }
}

ASP's #count directive enables working with quantities and cardinality constraints. The directive provides a natural way to reason about counting in the real world.

Imagine you need to know how many students are in a class. You have facts about who the students are, but how do you get a count? Let's start with the simplest case:

student(alice ; bob ; charlie) .
total(N) ← N = #count{ S : student(S) } .

".  The result shows us there are 3 students:

 directive counts unique values that match a pattern. In this case, it counts distinct values of 

What if we need to count students enrolled in different classes? We can count while keeping track of which class we're counting:

class(math ; history) .
enrolled(alice, math) . enrolled(bob, math) .
enrolled(alice, history) . enrolled(bob, history) . enrolled(charlie, history) .

students_per_class(C,N) ← N = #count{ S : enrolled(S,C) }, class(C) .

The result shows us each class's enrollment: 

 emerges when we combine it with constraints. Say we want to ensure no class exceeds a maximum size:

⊥ ← #count{ S : enrolled(S,C) } > 2, class(C) .

it cannot be that any class has more than 2 students

 because there are three students in the history class. We also could have used 

This shows two different ways to express the same constraint — one directly using 

 and one using our previously defined count predicate. Both approaches are valid and choosing between them often comes down to readability and whether you need the intermediate count for other purposes.

Sometimes we want to count only items matching certain criteria. For example, counting students who take both math and history:

dual_enrolled(N) ← N = #count{ S : enrolled(S, math), enrolled(S, history) } .

The count only includes students appearing in both classes.

Let's extend our example to show how we can count with multiple conditions:

class(math ; history ; science) .
level(beginner ; advanced) .

enrolled(alice, math, advanced) .
enrolled(bob, math, beginner) .
enrolled(charlie, history, advanced) .
enrolled(alice, history, advanced) .

advanced_students(N) ← N = #count{ S,C : enrolled(S, C, advanced) } .

This shows how to count enrollments in advanced classes across all subjects. Note that if a student is in multiple advanced classes, they're counted multiple times.

Sometimes we want to count unique occurrences versus total occurrences. Compare these two counts:

unique_advanced(N) ← N = #count{ S : enrolled(S, _, advanced) } .
total_advanced(N) ← N = #count{ S,C : enrolled(S, C, advanced) } .

The first rule counts each student only once even if they're in multiple advanced classes, while the second rule counts each advanced enrollment separately.

 can be particularly powerful when combined with choice rules:

{ assign(S,C) : enrolled(S,C) } .
⊥ ← #count{ S : assign(S,C) } > 2, class(C) .

, generates all possible assignment combinations while ensuring no class has more than 2 students.

In this example, we want to ensure that our servers aren't overloaded by counting the tasks assigned to each server. We'll enforce a constraint that flags any server with more than two tasks as overloaded:

server(s1 ; s2 ; s3) .
task(t1 ; t2 ; t3 ; t4) .

assigned(t1, s1) . assigned(t2, s1) . assigned(t4, s1) .
assigned(t3, s2) . assigned(t4, s2) .

overloaded(S) ← #count{ T : assigned(T, S) } > 2, server(S) .

This pattern is common in resource allocation, scheduling conflicts, and configuration management where counting constraints enforce real-world limitations.

 and cardinality constraints serve different purposes:

Cardinality constraints generate possibilities, while 

 verifies properties about existing atoms.

 directive is one of ASP's most practical features, providing an intuitive way to work with quantities and enforce numerical constraints. It excels when you need to:

While cardinality constraints help generate possibilities, 

 helps verify properties about those possibilities. Together, they form a powerful toolkit for expressing real-world constraints that involve quantities. The natural way 

count the number of students in each class

" — mirrors how we think about these problems in everyday language, making ASP programs both readable and maintainable.

ASP-12 | Counting Things

Counting

Multiple Arguments

Counting with Constraints

Counting Specific Patterns

Advanced Counting Techniques

Counting with Multiple Conditions

Unique vs Non-Unique Counting

Using Count in Choice Rules

Example: Server Task Allocation

Counting vs Cardinality Constraints

Takeaways

More from Building Blocks in Surface Tension

Constraints

Default Negation

Join us on Discord

About Us

Info

Legal

Social

enrolled/3
alice	history	advanced
alice	math	advanced
bob	math	beginner
charlie	history	advanced

class/1
history
math
science

assigned/2
t1	s1
t2	s1
t3	s2
t4	s1
t4	s2