3.1 Polytomous knowledge structures and polytomous knowledge spaces

In this section, we extend the basic notions of knowledge space theory to the polytomous setting, where each item may have more than two ordered response categories. Throughout this section, we assume that each response scale (V_p,≤_p) is a nontrivial bounded poset (i.e., ). This excludes degenerate items with only one possible response value, which would carry no diagnostic information.

Let Q be a nonempty set of items. For each item , we denote by V_p the set of possible response values for that item, and by ≤_p a partial order on V_p where larger values correspond to higher mastery levels. Thus, (V_p,≤_p) is a bounded poset, with top element ⊤_p representing full mastery and bottom element representing no mastery. We work with the set V^Q and the notation K(p) as established in Section 2. On V^Q we consider the item-wise partial order

Since each (V_p,≤_p) is bounded, the product order makes a bounded poset as well. Its greatest and least elements are given explicitly by

where ⊤_p and are respectively the greatest and least elements of (V_p,≤_p). We call K⊤ the full knowledge state and the ignorant state.

Definition 3.1. Let Q be a non-empty set, each (V_p,≤_p) a nontrivial bounded poset, and nonempty. The pair is called a polytomous knowledge structure if

1. (i) contains the states K⊤ and ;
2. (ii) for every and every , there exists with K(p)=v.

Each element of is called a polytomous knowledge state, or simply a state.

Remark 3.1. The following points clarify Definition 3.1 and its relationship to existing work.

1. (1) Coverage condition. Condition (ii) requires that every item–value pair (p,v) is realized by some state. In our framework (states as functions with ), this is: . In Heller’s transversal view [21] (states as transversals of ), this is equivalently (where ). The equivalence follows from the natural bijection between functions and transversals.

Stefanutti et al. [22] impose no coverage condition – their definition only requires nonempty, with all items sharing the same lattice L. Ge [37] strengthens this by requiring ; Ge [38] follows Stefanutti et al.’s original framework. Wang et al. [39] adopts Heller’s uniform definition with .

1. (2) Comparison with Heller. Our definition differs from Heller’s [21] in two aspects: (a) we require only a bounded poset for each (V_p,≤_p), whereas Heller assumes a lattice; (b) we allow Q infinite, while Heller assumes finiteness.
2. (3) Comparison with Stefanutti et al. and Ge. Stefanutti et al. [22] define a polytomous structure as where L is a complete lattice (uniform scale) and nonempty. They do not require . Ge [38] follows this framework; Ge [37] strengthens it by explicitly requiring . Both Ge [37,38] further investigate granular structures and their correspondences.
   In contrast, our definition allows item-specific scales (V_p,≤_p) that need only be bounded posets, not necessarily lattices. This accommodates items with different rating formats (e.g., 3-point vs. 5-point scales), whereas Stefanutti et al. and Ge require a uniform scale.
3. (4) The dichotomous case. When (V_p,≤_p) = 2 for all p, we recover the classical setting. Condition (ii) is automatically satisfied. The isomorphism defined by translates between the two representations.

To develop a theory that includes closure under item-wise suprema, we now strengthen the assumption on response scales: each (V_p,≤_p) is assumed to be a nontrivial bounded complete join semilattice; that is, it has a top element ⊤_p, a bottom element with , and every subset has a supremum. Under this assumption, for any family we can define its item-wise supremum as the element corresponding to the tuple

Equivalently, is the unique element of V^Q satisfying for every .

Definition 3.2. A polytomous knowledge structure on V^Q is called a polytomous knowledge space if for every nonempty subset , the item-wise supremum belongs to . In this case, we also say that is closed under item-wise suprema.

Remark 3.2. Every polytomous knowledge space is automatically a bounded complete join semilattice. Its least element is , its greatest element is K⊤, and for any , the supremum in is computed componentwise: for each . This definition directly generalizes the classical notion of a knowledge space to polytomous items.

Not every polytomous knowledge structure is a knowledge space, as illustrated by the following example.

Example 3.1. Consider Q = {a,b} and with the order 0 < 1 < 2 < 3. Define

One can check that is a polytomous knowledge structure: it contains and , and for each and , there exists with K(p)=v. However, for , the item-wise supremum (1,1) does not belong to . Hence is not closed under item-wise suprema.

3.2 Atoms, join-irreducibility and the finite generation theorem

This subsection establishes the core theoretical result that enables our algorithms: every finite polytomous knowledge space has a finite generating base consisting of its completely join-irreducible elements. We begin by recalling the notion of span, which formalizes the idea of generating a space from a set of elements.

Definition 3.3. Let Q be a nonempty set and V_p a nontrivial bounded complete join semilattice for each . For any , the span of is defined as:

We say that spans

The central concept for our decomposition theory is that of an atom—a minimal knowledge state that contains a particular completely join-irreducible value at a particular item.

Definition 3.4. Let be a polytomous knowledge structure on V^Q, where Q is nonempty and for each , (V_p,≤_p) is a nontrivial bounded complete join semilattice. For any and , if there exists such that

1. (i) A(p) = v_p;
2. (ii) for any , if and B(p) = v_p, then B = A,

then A is called an atom of at (p, v_p). Element is called an atom of if there exist and such that K is an atom of at (p, v_p). The set of all atoms of is denoted by and is called the atomic base of .

An atom represents the most elementary knowledge component containing a specific join-irreducible value at a specific item. To connect atoms with the order-theoretic notion of join-irreducibility, we need the following property of the value lattices.

Definition 3.5. A nontrivial bounded complete join semilattice (L,≤) is called supremum-generated if every element satisfies

Remark 3.3. Every finite lattice is supremum-generated. In the infinite case, supremum-generatedness is a nontrivial condition requiring that every element can be reconstructed from its completely join-irreducible components.

Theorem 3.1. Let be a polytomous knowledge space on V^Q and for each , (V_p,≤_p) be a supremum-generated bounded complete join semilattice. Then .

Proof. (⊆) Assume K is an atom of , i.e., . Then there exist and such that K is an l-atom at q. Let be such that . Then . Since l is join-irreducible in V_q, there exists some with F(q) = l. As and K is minimal among states containing l at q, we must have F = K. Hence , so K is join-irreducible in , i.e., .

(⊇): Let , i.e., K is join-irreducible in . Assume, for contradiction, that , meaning that K is not an atom. Since K is not an atom, by Definition 3.4, K fails to be an atom at every pair (q,w) with , , and . This implies that for each such (q,w), there exists a state satisfying:

1. (i) J_q,w(q) = w;
2. (ii) ;
3. (iii) J_q,w ≠ K (otherwise K would be minimal for (q,w)).

Consider the set

We claim that . First, since each , we have . For the reverse inclusion, fix . Because is supremum-generated,

For each such w, we have J_q,w(q) = w, hence

Therefore . Thus . But because every J_q,w ≠ K. This contradicts the assumption that K is join-irreducible in . Hence . □

Theorem 3.2. Let Q be a finite set, each (V_p,≤_p) a finite lattice, and a polytomous knowledge space on V^Q. Then is finite and

Proof. First, since Q is finite and each V_p is finite, the product set is finite. As , it follows that is finite. The inclusion is immediate because and is closed under arbitrary item-wise joins. For the reverse inclusion , we proceed by induction on the height of elements in the poset . Define the height h(K) of a state as the length of the longest chain from the bottom element K_⊥ to K. Because is finite, h(K) is a well-defined nonnegative integer for every .

Base case (h(K) = 0): Then . By definition of , the empty join equals K_⊥, so .

Inductive step: Assume that for all with h(K′) < h(K), we have . We consider two cases:

Case 1: K is join-irreducible in . Then , and trivially .

Case 2: K is not join-irreducible in . Since is a finite join semilattice (Remark 3.2), every element equals the join of all elements strictly below it. Take ; this set is nonempty because h(K) > 0 (so ). Then and by construction. Each satisfies , hence h(F) < h(K). By the induction hypothesis, each can be expressed as a join of join-irreducible elements: for some . Consequently,

which expresses K as a join of elements from . Hence .

By induction, every belongs to . Therefore . Combining the two inclusions, we obtain , completing the proof. □

Theorem 3.2 guarantees that every finite polytomous knowledge space—regardless of further structural properties—possesses a finite generating set consisting precisely of its join-irreducible elements. Moreover, under the mild assumption that each value lattice (V_p,≤_p) is supremum-generated, Theorem 3.1 shows that these join-irreducible elements coincide with the atoms of the space. These results hold without requiring any additional structural conditions. Consequently, the algorithms developed in Section 4, which rely solely on the existence of such a finite generating set, are applicable to all finite polytomous knowledge spaces.

Definition 3.6. A polytomous knowledge structure on V^Q is called a simple polytomous knowledge space if for every nonempty subset , the item-wise infimum belongs to . In this case, we also say that is closed under item-wise infima.

Example 3.2 (Finite free combination model). Let Q = {a, b} with (ordered 0 < 1 < 2). Define

It is straightforward to verify that satisfies Definition 3.6: and belong to ; every pair (p,v) appears in some state; and for any nonempty , the item-wise infimum belongs to (a simple case analysis). Thus is a simple polytomous closure space.

Example 3.3 (Global synchrony model). Let Q be a nonempty set. For any , let

ordered as real numbers, where . Thus 1 is the greatest and 0 the least element. Define

the set of all constant functions. The structure clearly contains (constant 0) and K⊤ (constant 1), and saturates Q × V (for any , the constant function with value v provides the required pair). To see that it is closed under item-wise infima, take any nonempty . Each is constant: K(p) ≡ c_K for some . Let (the infimum in the real order). Since V is a complete chain, . Then the constant function satisfies . Hence is a simple polytomous closure space. This model represents an extreme scenario where a learner’s performance is perfectly synchronized across all items, determined by a single global proficiency level.

Example 3.4 (Constant affine-subspace model). Let Q be nonempty, A a real affine space. For each , set (affine subspaces ordered by inclusion). Define

and belong to , and saturation holds because every affine subspace M yields a constant function in . For closure under item-wise infima, given , each is constant with value M_K. Then is the constant function with value , which is an affine subspace, hence in .

Remark 3.4. The preceding examples exhibit the flexibility of the simple polytomous closure-space framework:

1. (i) Example 3.2 illustrates a finite discrete case with mild inter-item constraints.
2. (ii) Example 3.3 represents an extreme global synchrony model.
3. (iii) Example 3.4 showcases closure spaces with geometric value lattices.

While these structures satisfy the definition, they illustrate that simple closure spaces alone are either overly restrictive (perfect synchrony) or lack mechanisms for encoding rich prerequisite relationships between items. The atomic decomposition theory developed in Section 3.3 will provide a more powerful framework for constructing structured knowledge models that capture meaningful dependencies while maintaining computational efficiency.

Proposition 3.1. Let be a simple polytomous closure space. For any define

Then is a closure operator on and its set of fixed points is exactly .

Proof. We verify the three axioms of a closure operator:

1. (i) Since is the greatest lower bound of states containing K, we have .
2. (ii) If , then

The infimum of a larger set is smaller (or equal), hence .

(iii) First, note that the set is non-empty because and . Since is a simple polytomous closure space, it is closed under arbitrary non-empty item-wise infima. Therefore belongs to . To prove , first note that by (i) we already have . For the opposite direction, consider . Because , it belongs to ; consequently . Hence is idempotent.

If , then K is the least element of , so . Conversely, if , then K is the infimum of a non-empty family of elements of . Since is closed under non-empty item-wise infima, . Thus . □

The following proposition establishes a duality between knowledge spaces and closure spaces through complementation.

Proposition 3.2. Let be a polytomous knowledge space where each (V_p,≤_p) is a Boolean algebra. Define the complement state and the dual structure . Then is a simple polytomous closure space.

Proof. Since each (V_p,≤_p) is a Boolean algebra, the complement operation is an order-reversing involution.

1. (i) contains K⊤ and . Indeed, , so ; similarly , so .
2. (ii) For any and , let . Because is a knowledge space, there exists with K(p) = u. Then and .

Let be non-empty. For each , the meet in V_p satisfies

Define by . Since is closed under item-wise joins, , and therefore . By construction, equals the item-wise meet of . □

The mathematical framework developed thus far provides the necessary foundation for the atomic decomposition theory introduced in the next subsection. This theory reveals how every knowledge state can be uniquely represented as a combination of fundamental, indivisible components—a decomposition essential for achieving the computational efficiency required by practical assessment systems.

3.3 Granular polytomous knowledge spaces

While Theorem 3.2 guarantees a generating base for every finite space, an additional structural condition—granularity—yields stronger representation properties.

Definition 3.7. Let be a polytomous knowledge structure on V^Q. It is said to be granular if for any , any , and , K(p) = v implies that there exists an atom B at (p, v) such that .

Remark 3.5. If a polytomous knowledge structure is granular, then for every we necessarily have ; that is, every non-bottom value in V_p must be join-irreducible. Consequently, value lattices such as the diamond lattice (where the top element 3 satisfies and is therefore not join-irreducible) cannot appear in a granular structure. Granularity thus imposes a strong constraint on the admissible value lattices, essentially limiting them to chains or other lattices in which no element can be expressed as a nontrivial join of strictly smaller elements.

Theorem 3.3. Let be a granular polytomous knowledge space on V^Q and for each , (V_p,≤_p) be a complete lattice. Then

(1) every polytomous knowledge state admits a unique decomposition into atoms, i.e.,

(2) is generated by its atomic base, i.e.,

Proof. (1) Let and define . Let . Clearly since each satisfies . Suppose for contradiction that . Then there exists some such that J(p) < K(p). Since is granular, there exists an atom with and A₀(p) = K(p). But then by definition, so , implying , contradiction. Therefore J = K, i.e., .

(2) Denote and . We prove . Since is a polytomous knowledge space, it is closed under joins of arbitrary subsets and joins are defined item-wise. For any , we have . In particular, for , . Hence, . On the other hand, let be arbitrary. Define the set

We show that . Obviously, because every element of S_K is below K. Conversely, we need to show that for all , . If , the inequality holds trivially. If , then by the granularity of , there exists a v-atom at p such that . Therefore, and A(p) = v. Consequently,

Thus, . It follows that . Therefore, . □

Definition 3.8. Let be a granular polytomous knowledge space on V^Q and for each , (V_p,≤_p) be a complete lattice. For any , the representation

is called the atomic decomposition of K.

Theorem 3.4. Let be a granular polytomous knowledge space. For any :

1. (1) ,
2. (2) if and only if ;
3. (3) If is also meet-closed with item-wise meets, then .

Proof. (1) If , then or , so , hence . Conversely, if , then . Since A is join-irreducible and , there must exist some such that . But A and B are both atoms, so implies A = B, hence .

(2) If , then any satisfies , so . Conversely, if , then .

(3) If , then and , so . Conversely, if , then and , so , hence . □

Proposition 3.3. Let be all granular polytomous knowledge spaces on V^Q and for each , (V_p,≤_p) be a complete lattice, and their corresponding atomic bases. Then there exists a bijection .

Proof. We construct mutually inverse mappings as follows.

1. (i) Define by ;
2. (ii) Define by .

Let and . By Theorem 3.3 (2), we have:

Hence, . Let . Then for some . Let . We show that . First, take any . We prove B is join-irreducible in . Suppose for some . Since , each can be written as for some . Thus,

Let . Then . Since B is an atom (in particular, join-irreducible) in the original space and , the join-irreducibility of B in implies that . Hence there exists some such that , i.e., . But since (as is an upper bound of T), we have K = B. Therefore , proving that B is join-irreducible in . Consequently . Conversely, take any . Then A is join-irreducible in and , so for some . Since A is join-irreducible in , there exists such that A = B. Hence, . Therefore, , i.e., , and so . □

Granular polytomous knowledge spaces enjoy a unique atomic decomposition and a bijective correspondence with their bases (Proposition 3.3). Non-granular polytomous knowledge spaces, while lacking these stronger properties, still possess a finite generating base (Theorem 3.2). The following example illustrates this atomic decomposition in a concrete setting.

Example 3.5 (A granular space). Let Q = {a, b} and with the order 0 < 1 < 2. Consider the set

Let be the set of all joins of subsets of , including the empty join . The states in are:

Thus . The space is closed under item-wise joins by construction, since . Moreover, every pair (p,v) appears at least once, hence is a polytomous knowledge space. The set is precisely the set of join-irreducible elements (atoms) of .

We verify that (1,1) is join-irreducible; the other two elements are treated similarly. Suppose for some finite non-empty subset . Because 1 is join-irreducible in the chain V_a, from we obtain that there exists some with F_a(a)=1. Similarly, from we obtain some with F_b(b)=1. The only state in with both a = 1 and b = 1 is K₂=(1,1). Because and , the set cannot consist solely of K₁=(0,0). Thus , proving K₂ is join-irreducible in . Moreover, K₂ is minimal with respect to the property of containing the item-value pairs (a,1) and (b,1); any proper lower state would miss at least one of these two pairs. Consequently K₂ is an atom. The same reasoning shows that each element of is an atom.

Consider the state K₇=(2,2). Its atomic decomposition (in the sense of Definition 3.8) is:

Notice that K₇ also equals the join of just K₃ and K₄:

This illustrates that while every state can be expressed as the join of all atoms below it (the canonical atomic decomposition), a minimal generating subset may also exist.

Example 3.6 (A non-granular space). Consider Q = {a, b, c}, where each has a diamond-shaped response value lattice V_p = {0, 1, 2, 3} with the order structure:

1. (i) 0 < 1 < 3;
2. (ii) 0 < 2 < 3;
3. (iii) 1 and 2 are incomparable,

as is illustrated in Figure?? (Fig 1).

Note that the diamond lattice cannot appear in any granular polytomous knowledge space because its top element is not join-irreducible, violating the condition required by granularity. Consider the set

Let be the set of all joins of subsets of , including the empty join . The states in can be enumerated by considering all subsets of . A systematic computation yields the following distinct states (each represented as a triple (v_a, v_b, v_c)):

Thus . The space is closed under item-wise joins by construction, since . Moreover, every pair (p,v) appears at least once, hence is a polytomous knowledge space.

The set is precisely the set of join-irreducible elements (atoms) of . We verify this for (1,1,0); the other four elements are treated similarly. Suppose for some finite non-empty subset . Because 1 is join-irreducible in the diamond lattice V_a, from we obtain that there exists some with F_a(a)=1. Similarly, from we obtain some with F_b(b)=1. Since , every must have F(c)=0. The only states in with c = 0 are K₁=(0,0,0) and K₂=(1,1,0). Because , the set cannot consist solely of K₁. Thus , proving K₂ is join-irreducible in . Moreover, K₂ is minimal with respect to the property of containing both (a,1) and (b,1); any proper lower state would miss at least one of these two item-value pairs. Consequently K₂ is an atom. The same reasoning shows that each element of is an atom.

Consider the state K₁₁ = (2,2,3). Its expression as a join of atoms is:

since

Thus K₁₁ can be expressed as a join of two atoms, demonstrating that even in a non-granular polytomous knowledge space—where the value lattice contains non-join-irreducible elements like 3—states can still be represented as joins of atoms. However, the failure of granularity means that not every non-bottom value v is guaranteed to have an atom supporting it; for example, the value 3 in the diamond lattice lacks such a guarantee, which prevents the space from satisfying Definition 3.7.

The algorithms developed in Section 4 rely only on Theorem 3.2; they do not require the space to be granular. Hence, they are applicable to both examples above, as well as to any other finite polytomous knowledge space.

4.1 Atomic base extraction for polytomous knowledge spaces

We begin with a straightforward algorithm for identifying join-irreducible elements.

Algorithm 1 Direct Base Extraction by Definition

Require: Finite knowledge space

Ensure: Set of join-irreducible elements

1:

2: for each do

3:  

4:  

5:  if then

6:    K is an atom

7:   continue

8:  end if

9:  for each nonempty subset do Examine all proper subsets

10:   if then

11:    

12:    break

13:   end if

14:  end for

15:  if isJI then

16:   

17:  end if

18: end for

19: return

We now analyze the complexity of Algorithm 1. Let be the number of states and m = |Q| the number of items. Each state is represented as an m-tuple of values, requiring storage space. The worst-case time complexity is . For a given state K, if we let denote the number of states strictly below K, the per-state complexity is . The exponential factor 2^N makes this algorithm impractical for moderate-sized knowledge spaces: with N = 20 items, each state may require checking up to 2²⁰ ≈ 10⁶ subsets, rendering real-time computation infeasible.

Example 4.1. Consider the polytomous knowledge space from Example 3.6. Applying Algorithm 1: States K₂=(1,1,0), K₃=(2,0,2), K₄=(0,2,1), K₅=(0,1,2), and K₆=(1,0,1) each have only K₁=(0,0,0) strictly below them. Since for each , all five are join-irreducible and are added to the atomic base. For non-join-irreducible states, we find generating subsets: , , and (among many other representations). Hence these states are skipped. The algorithm returns the atomic base

which matches the atomic base given in Example 3.6. all five are join-irreducible and are added to the atomic base. (States K₈ through K₁₈ are similarly found to be non-join-irreducible.)

The direct approach (Algorithm 1) follows exactly the definition of join-irreducibility by enumerating all proper subsets of lower states, but its worst-case time complexity is exponential in N (). While theoretically correct and useful for illustrating the concept, it becomes impractical for knowledge spaces with more than a dozen states. We now present an alternative algorithm (Algorithm 2) that achieves quadratic time complexity in the worst case by exploiting the structural properties of knowledge spaces. Algorithm 2 is recommended for practical applications with larger state sets, whereas Algorithm 1 serves primarily as a pedagogical tool or for very small spaces.

Algorithm 2 Base Construction for Polytomous Knowledge Spaces

Require: A polytomous knowledge space where

  (i) is finite and closed under item-wise joins;

  (ii) is a finite item set;

  (iii) Each is a finite lattice.

Ensure. The set of join-irreducible elements

1:  Step 1: Sorting

2:  Compute a linear extension of such that:

3:    for all i, j

4:                Sorting requires comparisons

5:  Let be the first element in the sorted order

6:  Step 2: Initialization

7:              Set of discovered join-irreducible elements

8:  Initialize array J[1..N] where each

9:  for i = 1 to N do

10:           J[i] will accumulate join of join-irreducibles

11:  end for

12:  Step 3: Join-irreducible Identification

13:  for i = 2 to N do       Process in sorted order, skip K_⊥

14:   if J[i] = K_i then

15:    continue        K_i is generated by previously found join-irreducibles

16:   end if

17:          K_i is join-irreducible

18:   for j = i+1 to N do

19:    if then

20:          Accumulate join for supersets

21:    end if

22:   end for

23:  end for

24:  return

We now analyze the complexity of Algorithm 2. Let be the number of states and m = |Q| the number of items. Each state is represented as an m-tuple of values, requiring storage space for the knowledge states and the J array. The algorithm proceeds in two main phases. First, the states are sorted according to a linear extension of , which requires time using pairwise comparisons. Second, the join-irreducible identification phase iterates through all states and, for each state K_i, updates the J array for all supersets K_j with j > i. This involves at most O(N²) iterations, each requiring O(m) time for join operations and comparisons, yielding a total of for this phase. Thus, the overall worst-case time complexity is , which is optimal for pairwise-comparison-based approaches. The space complexity is , dominated by storing the knowledge states and the J array.

Proposition 4.1. Let be a finite polytomous knowledge space closed under item-wise joins, and let be a linear extension of with . Algorithm 2 returns exactly the set of join-irreducible elements of .

Proof. We show that after the main loop (Step 3) finishes, the output set coincides with . The argument relies on two invariants maintained throughout the execution. First, at the start of iteration i (with 2 ≤ i ≤ N), for every we have

so J[j] is the join of all join-irreducible elements discovered so far that lie below K_j. Second, all join-irreducible elements among are already contained in .

Base case Before iteration i = 2 we have and for all j; both invariants hold trivially.

Inductive step Assume the invariants hold at the start of iteration i. We consider two possibilities.

1. (i) If J[i]=K_i, then by the first invariant K_i equals the join of all join-irreducibles discovered so far that are below K_i. Because the order is a linear extension, every element strictly below K_i has index smaller than i, and by the second invariant all join-irreducibles among them are already in . Hence K_i can be expressed as a join of join-irreducible elements strictly below it, which means K_i is not join-irreducible. The algorithm therefore correctly skips K_i, and the invariants remain true.
2. (ii) If , suppose for contradiction that K_i were not join-irreducible. Then there exists a non-empty subset with and . Every element of S is strictly below K_i, hence has index <i. By the second invariant, all join-irreducible elements occurring in S are contained in . Because joins are defined item-wise and is join-closed, the join of S coincides with the join of those join-irreducibles, which by the first invariant is contained in J[i]. Consequently J[i]=K_i, contradicting . Thus K_i must be join-irreducible. The algorithm adds K_i to and, in the inner loop, updates for every j > i with . This update preserves the first invariant because K_i is now a discovered join-irreducible below those K_j; the second invariant is clearly maintained as well.

After the last iteration (i = N), the second invariant guarantees that every join-irreducible element of has been placed in , while the first case ensures that no non-join-irreducible element has been added. Hence .

Example 4.2. Consider the polytomous knowledge space from Example 3.6. We apply Algorithm 2 to extract the atomic base .

Step 1: Sorting. One linear extension of orders the 19 states as .

Step 2: Initialization. ; J[1..19] initialized to K₁=(0,0,0).

Step 3: Join-irreducible Identification. For , each K_i satisfies , so all five are added to . Their propagation updates the J array for supersets. Consequently, several later states satisfy J[i]=K_i and are skipped, e.g.,:

1. (i) K₇: J[7]=K₇ (since );
2. (ii) K₈: J[8]=K₈ ();
3. (iii) K₉: J[9]=K₉ ();
4. (iv) K₁₀: J[10]=K₁₀ ();
5. (v) K₁₁: J[11]=K₁₁ ();
6. (vi) K₁₉: J[19]=K₁₉ (join of all five atoms).

The algorithm returns , matching the atomic base from Example 3.6.

Example 4.2 demonstrates that in diamond lattices, the intermediate values (1 and 2) are the true atoms, while the top values (3) can be generated as joins of the intermediate atoms, correctly reflecting the lattice structure and thus confirming the algorithm’s correctness.

4.2 Polytomous knowledge space generation from atomic bases

Once the atomic base is identified, Algorithm 3 generates the complete knowledge space by computing joins of all atom subsets via breadth-first search (BFS). The algorithm starts from the ignorant state K_⊥ (the empty join) and systematically explores combinations by joining each current state with base atoms. New states are added to both the knowledge space and the exploration queue. The visited set prevents redundancy while ensuring all atom subsets are considered. The BFS approach ensures that each state is generated exactly once, achieving optimal complexity for this generation task. Termination is guaranteed for finite bases and value lattices, with correctness following directly from the atomic decomposition theorem.

Algorithm 3 Basic BFS Knowledge Space Generation

Require: Atomic base where

  (i) each A_i is a join-irreducible;

  (ii) ;

  (iii) each (V_p,≤_p) is a finite lattice.

Ensure: Knowledge space generated by the atomic base

1:             Start with empty join (ignorant state)

2:           BFS queue initialization

3:           Track visited states

4:  while queue is not empty do

5:   

6:   for each do

7:            item-wise join

8:    if then

9:     

10:     queue.enqueue(K_new)

11:     

12:    end if

13:   end for

14:  end while

15:  return

We now analyze the complexity of Algorithm 3. Let denote the number of atoms (base size), m = |Q| the number of items, and the number of states in the generated space. The algorithm performs a breadth-first search traversal starting from the ignorant state . Each of the N states is dequeued once, and for each dequeued state, we attempt joins with all t atoms. Each join operation requires O(m) time to compute the componentwise supremum. Thus, the total time complexity is . The space complexity is , dominated by storing the generated knowledge states.

Example 4.3. Consider the atomic base . Applying Algorithm 3:

1. (i) Initialization: , queue .
2. (ii) First iteration: generates all five atoms, adding them to .
3. (iii) Subsequent iterations: The BFS explores combinations level by level. For example, with M=(1,1,0) we obtain new states , , , and .

After BFS completion, contains the 19 states:

This matches Example 3.6, confirming correctness.

Theorem 4.1. Let be a polytomous knowledge space on V^Q with base . For any and , the following two conditions are equivalent:

1. (a) For all , if then ;
2. (b) For all , if then .

Proof. (a) ⇒ (b): Let such that . Since is a knowledge space, . We compute

where the last equality holds because . By condition (a), we have . But since by the definition of join, we conclude , which implies .

(b) ⇒ (a): Let such that . Since is a knowledge space, K can be expressed as the join of base elements: . For any with , we have

By condition (b), this implies . Therefore, all base elements contained in K are also contained in M, which means . □

Corollary 4.1. For and , the following statements are equivalent:

1. (a) ;
2. (b) There exists such that and ;
3. (c) (i.e., and ).

Proof. The equivalence between (a) and (c) follows directly from the definition of proper containment. We now prove . Assume . By the atomic decomposition, . If all such D satisfied , then we would have , contradicting . Hence, there exists some with but . Conversely, assume there exists such that and . If , then , contradicting . Therefore, . □

Algorithm 4 Incremental Construction Illustrating Theorem 4

Require: Base of join-irreducible elements;

  Item set ;

  Each (V_p,≤_p) is a finite lattice

Ensure: Knowledge space generated by the base

1:             Initialize with ignorant state

2:             Set of states to be processed

3:           Track visited states

4:  while do

5:   Pick           , e.g., FIFO queue

6:   

7:   for each do

8:            Compute the join

9:    if K_new = M then

10:     continue No change; skip

11:    end if              By Corollary 2, implies B itself satisfies and .

12:    if then

13:    

14:    

15:    

16:    end if

17:   end for

18:  end while

19:  return

We now analyze the complexity of Algorithm 4. Let denote the number of atoms (base size), m = |Q| the number of items, and the number of states in the generated space. The algorithm processes states from a queue, similar to breadth-first search. Each of the N states is dequeued once, and for each dequeued state, we attempt joins with all t atoms. Each join operation requires O(m) time to compute the componentwise supremum. Thus, the total time complexity is . The space complexity is , dominated by storing the knowledge states and the working sets.

Algorithm 4 demonstrates how Corollary 4.1 guarantees that every non-trivial join produces a new state (unless it has already been visited). Since the condition of Corollary 4.1 is automatically satisfied by B itself when , the algorithm reduces to the same breadth-first search exploration as Algorithm 3. It is included here primarily to illustrate how the theoretical results of Section 3 inform the design of generation procedures, not as a distinct practical method.

Example 4.4. Consider the base

from Example 3.6. Applying Algorithm 4 produces the knowledge space .

1. (i) Initialization: The queue initially contains only .
2. (ii) First expansion: is dequeued. For each , the join differs from M, so all five atoms are added to and enqueued.
3. (iii) Subsequent expansions: As states are dequeued, they are joined with every . For example: When M = (1,1,0) and B = (2,0,2), we obtain (3,1,2), a new state; When M = (2,0,2) and B = (0,2,1), we obtain (2,2,3), another new state.
4. (iv) Skipping trivial joins: The check K_new = M (line 9) prevents redundant processing. For instance, yields K_new = M, so the iteration is skipped.

Corollary 4.1 guarantees that whenever , the join is non-trivial and, unless already present in , introduces a new knowledge state. After the BFS completes, contains the 19 states listed in Example 3.6. The execution demonstrates how Corollary 4.1 guarantees that whenever , the join is different from M (and therefore, unless it has already been generated, represents a new knowledge state).

The two space generation algorithms present complementary pedagogical perspectives. Algorithm 3 employs a straightforward breadth-first search strategy, while Algorithm 4 explicitly illustrates how the theoretical result (Corollary 4.1) guarantees that every non-trivial join yields a new state. Both algorithms generate the complete knowledge space , share the same worst-case time complexity (where ), and exhibit identical space complexity . Their correctness follows from the finite generation theorem (Theorem 3.2), which ensures that every state in a finite polytomous knowledge space can be expressed as a join of join-irreducible elements. Algorithm 3 is recommended for practical implementations due to its simplicity and clarity. Algorithm 4 is included primarily to illustrate how the theoretical guarantees of Section 3 directly inform the design of generation procedures, even though in this case the theoretical condition does not alter the computational steps.

4.3 Algorithm comparison and selection

The four algorithms presented in Sections 4.1 and 4.2 offer complementary approaches to base extraction and space generation. Table 1 summarizes their key characteristics to guide algorithm selection, where , , m = |Q|. Note that space complexity is for all algorithms.

For atomic base extraction,

1. (i) Algorithm 1 follows directly from the definition of join-irreducibility but has exponential worst-case time complexity, making it suitable only for very small knowledge spaces or for illustrating the concept.
2. (ii) Algorithm 2 achieves quadratic complexity by exploiting the order structure of the knowledge space and is recommended for practical applications with moderate to large state spaces.

For polytomous knowledge space generation,

1. (i) Algorithm 3 employs a standard BFS approach, generating all combinations and filtering via a visited set. Its simplicity and efficiency make it the method of choice for all practical purposes.
2. (ii) Algorithm 4 includes an explicit comment (line 12) that references Corollary 4.1, highlighting where the theoretical guarantee ensures that each non-trivial join produces a new state.

In practice, Algorithm 2 and Algorithm 3 form the recommended pipeline: extract the base with Algorithm 2, then generate the full knowledge space with Algorithm 3. This combination provides polynomial-time complexity and is scalable to realistic problem sizes. See Examples 4.1 and 4.2 for concrete executions of Algorithms 1 and 2, respectively.