odis 2026.4.0

Formal Concept Analysis algorithms and data structures
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

# odis — Formal Concept Analysis in Rust

`odis` is a Rust library for [Formal Concept Analysis](https://en.wikipedia.org/wiki/Formal_concept_analysis).
It works on formal contexts (objects × attributes incidence tables) and currently provides
concept enumeration, implication bases, lattice drawing, and attribute exploration.

## Installation

```toml
[dependencies]
odis = "2026.3.0"
```

## Quick start

```rust
use odis::{FormalContext, algorithms::NextClosure};
use odis::traits::ConceptEnumerator;

// Parse a Burmeister (.cxt) file
let bytes = std::fs::read("context.cxt").unwrap();
let ctx = FormalContext::<String>::from(&bytes).unwrap();

// Enumerate all formal concepts
for (extent, intent) in NextClosure.enumerate_concepts(&ctx) {
    println!("extent: {:?}  intent: {:?}", extent, intent);
}

// Or use the built-in shortcut (defaults to NextClosure)
let concepts: Vec<_> = ctx.concepts().collect();
```

## Algorithms

### Concept enumeration

[`ConceptEnumerator`](https://docs.rs/odis/latest/odis/traits/trait.ConceptEnumerator.html) is implemented by:

| Struct | Algorithm |
|---|---|
| `NextClosure` | Lectic-order enumeration |
| `Fcbo` | Fast Close-by-One |

### Implication basis

```rust
use odis::algorithms::CanonicalBasis;
use odis::traits::ImplicationEngine;

let basis = CanonicalBasis.compute_named_basis(&ctx);
for (premise, conclusion) in &basis {
    println!("{:?} → {:?}", premise, conclusion);
}
```

### Lattice drawing

[`DrawingAlgorithm`](https://docs.rs/odis/latest/odis/traits/trait.DrawingAlgorithm.html) is implemented by:

| Struct | Algorithm |
|---|---|
| `DimDraw { timeout_ms }` | Realizer-based drawing algorithm; `timeout_ms = 0` for unbounded |
| `Sugiyama` | Hierarchical layout via `rust-sugiyama` |

```rust
use odis::algorithms::{DimDraw, NextClosure};
use odis::traits::{ConceptEnumerator, DrawingAlgorithm};

let lattice = ctx.concept_lattice().unwrap();
let drawing = DimDraw { timeout_ms: 500 }.draw(&lattice).unwrap();
```

### Iceberg concept lattices

```rust
use odis::algorithms::Titanic;
use odis::traits::IcebergConceptEnumerator;

// Concepts whose extent has at least 3 objects
let iceberg = Titanic.enumerate_named_concepts(&ctx, 3);
```

### Attribute exploration

`ExplorationMachine` drives interactive attribute exploration over a growing context.
The state machine separates exploration logic from I/O.

## Formal context format

Contexts are parsed from the [Burmeister `.cxt` format](https://fc-bug-search.uni-wuppertal.de/cxt-file-format):

```
B

2
2

bird
fish
flies
lives_in_water
X.
.X
```

## API documentation

```bash
cargo doc -p odis --no-deps --open
```

## License

[AGPL-3.0-only](LICENSE)