sequential_pattern_mining_common — Logtalk 3.100.1

category

# `sequential_pattern_mining_common`

Shared predicates for sequential pattern miner dataset validation, support counting, and pattern ordering helpers.

Availability:
`logtalk_load(sequential_pattern_mining_protocols(loader))`
Author: Paulo Moura
Version: 1:0:0
Date: 2026-04-29
Compilation flags:
`static`
Extends:
`public` pattern_miner_common
Uses:
list
type
Remarks:
(none)
Inherited public predicates:
check_option/1 check_options/1 check_pattern_miner/1 default_option/1 default_options/1 diagnostic/2 diagnostics/2 export_to_clauses/4 export_to_file/4 mine/2 mine/3 option/2 option/3 pattern_miner_options/2 print_pattern_miner/1 valid_option/1 valid_options/1 valid_pattern_miner/1

## Public predicates

(no local declarations; see entity ancestors if any)

## Protected predicates

### `check_sequences/4`

Validates the collected dataset sequences and returns the maximum total sequence length.

Compilation flags:
`static`
Template:
`check_sequences(Dataset,ItemDomain,Sequences,MaxSequenceLength)`
Mode and number of proofs:
`check_sequences(+object_identifier,+list(atom),+list(pair(integer,list(list(atom)))),-integer)` - `one`

### `pattern_length/2`

Computes the total number of items in a sequential pattern.

Compilation flags:
`static`
Template:
`pattern_length(Pattern,PatternLength)`
Mode and number of proofs:
`pattern_length(+list(list(atom)),-integer)` - `one`

### `sort_patterns/2`

Sorts sequence patterns first by total item count and then lexicographically.

Compilation flags:
`static`
Template:
`sort_patterns(Patterns0,Patterns)`
Mode and number of proofs:
`sort_patterns(+list(compound),-list(compound))` - `one`

### `filter_patterns/3`

Filters sequence patterns by minimum total item count.

Compilation flags:
`static`
Template:
`filter_patterns(Patterns0,MinimumPatternLength,Patterns)`
Mode and number of proofs:
`filter_patterns(+list(compound),+integer,-list(compound))` - `one`

### `count_items/4`

Accumulates support counts for a list of items.

Compilation flags:
`static`
Template:
`count_items(Items,Count,ItemCounts0,ItemCounts)`
Mode and number of proofs:
`count_items(+list(atom),+integer,+list(pair(atom,integer)),-list(pair(atom,integer)))` - `one`

### `select_frequent_item_supports/3`

Selects the item supports that satisfy the minimum support count.

Compilation flags:
`static`
Template:
`select_frequent_item_supports(ItemCounts,SupportCount,FrequentItemSupports)`
Mode and number of proofs:
`select_frequent_item_supports(+list(pair(atom,integer)),+integer,-list(compound))` - `one`

### `sort_item_supports/2`

Sorts item supports lexicographically by item.

Compilation flags:
`static`
Template:
`sort_item_supports(ItemSupports0,ItemSupports)`
Mode and number of proofs:
`sort_item_supports(+list(compound),-list(compound))` - `one`

### `valid_sequence_patterns/2`

True when the patterns are valid `sequence_pattern(Pattern, Support)` terms over the given item domain with positive integer supports.

Compilation flags:
`static`
Template:
`valid_sequence_patterns(ItemDomain,Patterns)`
Mode and number of proofs:
`valid_sequence_patterns(+list(atom),+list(compound))` - `zero_or_one`

## Private predicates

(no local declarations; see entity ancestors if any)

## Operators

(none)