laman 0.0.1__tar.gz

laman-0.0.1/Cargo.lock

@@ -0,0 +1,211 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "autocfg"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "indoc"
+version = "2.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a37b2691796cffeb8a8cd305ac66e65841559f147f4e63231d0eafa4db5384d1"
+dependencies = [
+ "rustversion",
+]
+
+[[package]]
+name = "laman"
+version = "0.0.1"
+dependencies = [
+ "thiserror",
+]
+
+[[package]]
+name = "laman-py"
+version = "0.0.1"
+dependencies = [
+ "laman",
+ "pyo3",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.191"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65cd87c9a6d60536580b316ad985726104730a5151c99845f2490428ef91240a"
+
+[[package]]
+name = "memoffset"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "portable-atomic"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.107"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pyo3"
+version = "0.26.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ba0117f4212101ee6544044dae45abe1083d30ce7b29c4b5cbdfa2354e07383"
+dependencies = [
+ "indoc",
+ "libc",
+ "memoffset",
+ "once_cell",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+ "unindent",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.26.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fc6ddaf24947d12a9aa31ac65431fb1b851b8f4365426e182901eabfb87df5f"
+dependencies = [
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.26.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "025474d3928738efb38ac36d4744a74a400c901c7596199e20e45d98eb194105"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.26.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e64eb489f22fe1c95911b77c44cc41e7c19f3082fc81cce90f657cdc42ffded"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.26.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "100246c0ecf400b475341b8455a9213344569af29a3c841d29270e53102e0fcf"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "pyo3-build-config",
+ "quote",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
+
+[[package]]
+name = "syn"
+version = "2.0.119"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "3.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d78c8dee4c7bf0e14673097256fed6142ce9d3b85a408189d07482442145823b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
+
+[[package]]
+name = "thiserror"
+version = "2.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.9",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2c754d6c33795a1c324727428e5a7dedb5b06195f9890bdbcba760d3e246563"
+
+[[package]]
+name = "unindent"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"

laman-0.0.1/Cargo.toml

@@ -0,0 +1,39 @@
+# Virtual workspace manifest. The crates and the layer rule between them are
+# SEED.md §7 until docs/ARCHITECTURE.md is written (SEED.md §10.2).
+[workspace]
+resolver = "3"
+members = ["crates/*"]
+
+[workspace.package]
+version = "0.0.1"
+edition = "2024"
+rust-version = "1.85"
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/arris-labs/laman"
+homepage = "https://github.com/arris-labs/laman"
+# Resolved relative to this manifest, so every member inherits the one
+# workspace README as its crates.io front page.
+readme = "README.md"
+
+[workspace.dependencies]
+# Internal crates: path plus an exact version pin, so a version bump that
+# misses one fails `cargo check` (.agents/rules/git.md §The version).
+laman = { path = "crates/laman", version = "=0.0.1" }
+
+# External crates, pinned here and used with `workspace = true` (SEED.md §7).
+thiserror = "2.0"
+# `laman-py` only, and never on wasm32. Pinned to the minor, as in arris.
+# `extension-module` is `laman-py`'s own feature, set by maturin.
+pyo3 = { version = "0.26", default-features = false, features = ["macros", "abi3-py310"] }
+
+# Every crate opts in with `[lints] workspace = true` (.agents/rules/solver.md §API).
+[workspace.lints.rust]
+unsafe_code = "forbid"
+missing_docs = "warn"
+
+# No panics on any input (SEED.md §5): the hook and CI run clippy with
+# `-D warnings`, so these are errors there. Tests may unwrap (clippy.toml).
+[workspace.lints.clippy]
+unwrap_used = "warn"
+expect_used = "warn"
+panic = "warn"

laman-0.0.1/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: laman
+Version: 0.0.1
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Typing :: Typed
+Requires-Dist: pytest>=8 ; extra == 'test'
+Requires-Dist: mypy>=1.18 ; extra == 'test'
+Provides-Extra: test
+Summary: A deterministic 2D geometric constraint solver in pure Rust. Early release: the generic rigidity count of bar frameworks (Laman's theorem)
+Keywords: constraint solver,cad,sketch,geometry,rigidity
+License: MIT OR Apache-2.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Repository, https://github.com/arris-labs/laman
+
+# laman
+
+A deterministic 2D geometric constraint solver in pure Rust, for Rust and
+Python, built to be trusted.
+
+`laman` is a library for sketchers, code-CAD tools, mechanism designers and
+anything else that places points, lines, circles and arcs under geometric
+and dimensional constraints. Its aim: the exact remaining degrees of
+freedom of a sketch, the constraints to blame when it cannot be satisfied,
+smooth interactive dragging, and the same bits on every platform, under
+MIT OR Apache-2.0.
+
+## Status
+
+Early. The sketch solver is being designed and built in the open
+([`SEED.md`](https://github.com/arris-labs/laman/blob/main/SEED.md) is the
+charter). This release holds the combinatorial core the project is named
+after: the **generic rigidity count of a bar framework** in the plane.
+
+```rust
+// A square flexes: one internal freedom. A diagonal makes it rigid,
+// and a second diagonal is redundant.
+let bars = [(0, 1), (1, 2), (2, 3), (3, 0), (0, 2), (1, 3)];
+let r = laman::rigidity(4, &bars[..4]).unwrap();
+assert_eq!(r.dof, 1);
+let r = laman::rigidity(4, &bars).unwrap();
+assert_eq!(r.dof, 0);
+assert_eq!(r.redundant, vec![5]);
+```
+
+```python
+import laman
+
+r = laman.rigidity(4, [(0, 1), (1, 2), (2, 3), (3, 0), (0, 2), (1, 3)])
+assert r.dof == 0 and r.redundant == [5]
+```
+
+```sh
+cargo add laman
+pip install laman
+```
+
+## The name
+
+`laman` is named after Laman's theorem (G. Laman, *On graphs and rigidity
+of plane skeletal structures*, 1970), which says exactly when points
+joined by rigid bars in the plane are rigid: `2n − 3` bars for `n` points,
+and no subset of `k` points carrying more than `2k − 3` of them. Counting
+the freedom that remains, and saying where constraints are missing or in
+excess, is what this constraint solver is for. The name implies no
+endorsement by Laman or his estate.
+
+## Licence
+
+Licensed under either of [Apache License, Version 2.0](LICENSE-APACHE) or
+[MIT license](LICENSE-MIT) at your option. Unless you explicitly state
+otherwise, any contribution intentionally submitted for inclusion in this
+work by you, as defined in the Apache-2.0 license, shall be dual licensed
+as above, without any additional terms or conditions.
+

laman-0.0.1/README.md

@@ -0,0 +1,59 @@
+# laman
+
+A deterministic 2D geometric constraint solver in pure Rust, for Rust and
+Python, built to be trusted.
+
+`laman` is a library for sketchers, code-CAD tools, mechanism designers and
+anything else that places points, lines, circles and arcs under geometric
+and dimensional constraints. Its aim: the exact remaining degrees of
+freedom of a sketch, the constraints to blame when it cannot be satisfied,
+smooth interactive dragging, and the same bits on every platform, under
+MIT OR Apache-2.0.
+
+## Status
+
+Early. The sketch solver is being designed and built in the open
+([`SEED.md`](https://github.com/arris-labs/laman/blob/main/SEED.md) is the
+charter). This release holds the combinatorial core the project is named
+after: the **generic rigidity count of a bar framework** in the plane.
+
+```rust
+// A square flexes: one internal freedom. A diagonal makes it rigid,
+// and a second diagonal is redundant.
+let bars = [(0, 1), (1, 2), (2, 3), (3, 0), (0, 2), (1, 3)];
+let r = laman::rigidity(4, &bars[..4]).unwrap();
+assert_eq!(r.dof, 1);
+let r = laman::rigidity(4, &bars).unwrap();
+assert_eq!(r.dof, 0);
+assert_eq!(r.redundant, vec![5]);
+```
+
+```python
+import laman
+
+r = laman.rigidity(4, [(0, 1), (1, 2), (2, 3), (3, 0), (0, 2), (1, 3)])
+assert r.dof == 0 and r.redundant == [5]
+```
+
+```sh
+cargo add laman
+pip install laman
+```
+
+## The name
+
+`laman` is named after Laman's theorem (G. Laman, *On graphs and rigidity
+of plane skeletal structures*, 1970), which says exactly when points
+joined by rigid bars in the plane are rigid: `2n − 3` bars for `n` points,
+and no subset of `k` points carrying more than `2k − 3` of them. Counting
+the freedom that remains, and saying where constraints are missing or in
+excess, is what this constraint solver is for. The name implies no
+endorsement by Laman or his estate.
+
+## Licence
+
+Licensed under either of [Apache License, Version 2.0](LICENSE-APACHE) or
+[MIT license](LICENSE-MIT) at your option. Unless you explicitly state
+otherwise, any contribution intentionally submitted for inclusion in this
+work by you, as defined in the Apache-2.0 license, shall be dual licensed
+as above, without any additional terms or conditions.

laman-0.0.1/crates/laman/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "laman"
+description = "A deterministic 2D geometric constraint solver in pure Rust. Early release: the generic rigidity count of bar frameworks (Laman's theorem)"
+keywords = ["constraint-solver", "cad", "sketch", "geometry", "rigidity"]
+categories = ["mathematics", "science", "graphics"]
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+repository.workspace = true
+homepage.workspace = true
+readme = "README.md"
+
+[dependencies]
+thiserror.workspace = true
+
+[lints]
+workspace = true

laman-0.0.1/crates/laman/README.md

@@ -0,0 +1,59 @@
+# laman
+
+A deterministic 2D geometric constraint solver in pure Rust, for Rust and
+Python, built to be trusted.
+
+`laman` is a library for sketchers, code-CAD tools, mechanism designers and
+anything else that places points, lines, circles and arcs under geometric
+and dimensional constraints. Its aim: the exact remaining degrees of
+freedom of a sketch, the constraints to blame when it cannot be satisfied,
+smooth interactive dragging, and the same bits on every platform, under
+MIT OR Apache-2.0.
+
+## Status
+
+Early. The sketch solver is being designed and built in the open
+([`SEED.md`](https://github.com/arris-labs/laman/blob/main/SEED.md) is the
+charter). This release holds the combinatorial core the project is named
+after: the **generic rigidity count of a bar framework** in the plane.
+
+```rust
+// A square flexes: one internal freedom. A diagonal makes it rigid,
+// and a second diagonal is redundant.
+let bars = [(0, 1), (1, 2), (2, 3), (3, 0), (0, 2), (1, 3)];
+let r = laman::rigidity(4, &bars[..4]).unwrap();
+assert_eq!(r.dof, 1);
+let r = laman::rigidity(4, &bars).unwrap();
+assert_eq!(r.dof, 0);
+assert_eq!(r.redundant, vec![5]);
+```
+
+```python
+import laman
+
+r = laman.rigidity(4, [(0, 1), (1, 2), (2, 3), (3, 0), (0, 2), (1, 3)])
+assert r.dof == 0 and r.redundant == [5]
+```
+
+```sh
+cargo add laman
+pip install laman
+```
+
+## The name
+
+`laman` is named after Laman's theorem (G. Laman, *On graphs and rigidity
+of plane skeletal structures*, 1970), which says exactly when points
+joined by rigid bars in the plane are rigid: `2n − 3` bars for `n` points,
+and no subset of `k` points carrying more than `2k − 3` of them. Counting
+the freedom that remains, and saying where constraints are missing or in
+excess, is what this constraint solver is for. The name implies no
+endorsement by Laman or his estate.
+
+## Licence
+
+Licensed under either of [Apache License, Version 2.0](LICENSE-APACHE) or
+[MIT license](LICENSE-MIT) at your option. Unless you explicitly state
+otherwise, any contribution intentionally submitted for inclusion in this
+work by you, as defined in the Apache-2.0 license, shall be dual licensed
+as above, without any additional terms or conditions.

laman-0.0.1/crates/laman/src/lib.rs

@@ -0,0 +1,29 @@
+//! `laman`: a deterministic 2D geometric constraint solver in pure Rust.
+//!
+//! The solver (sketches of points, lines, circles and arcs, their
+//! constraints, the numerical solve and its diagnostics) is being built;
+//! `SEED.md` in the repository is the charter. This early release holds the
+//! combinatorial core the name comes from: [`rigidity`], the generic
+//! rigidity count of a bar framework in the plane (Laman's theorem), with
+//! the bars that are redundant named.
+//!
+//! ```
+//! use laman::rigidity;
+//!
+//! // A triangle is rigid; a fourth point on two bars makes it a rigid
+//! // "diamond"; one more bar across it is redundant.
+//! let bars = [(0, 1), (1, 2), (2, 0), (1, 3), (2, 3), (0, 3)];
+//! let r = rigidity(4, &bars).unwrap();
+//! assert_eq!(r.dof, 0);
+//! assert_eq!(r.redundant, vec![5]);
+//! ```
+#![forbid(unsafe_code)]
+
+mod rigidity;
+
+pub use rigidity::{Rigidity, RigidityError, rigidity};
+
+/// The README's Rust example runs as a doctest, so it cannot drift.
+#[doc = include_str!("../../../README.md")]
+#[cfg(doctest)]
+struct ReadmeDoctests;

laman-0.0.1/crates/laman/src/rigidity.rs

@@ -0,0 +1,246 @@
+//! Generic rigidity of bar frameworks in the plane, by the (2,3) pebble game.
+//!
+//! Laman's theorem (G. Laman, *On graphs and rigidity of plane skeletal
+//! structures*, 1970): for points in generic position, a set of bars is
+//! independent exactly when every subset of `k ≥ 2` points spans at most
+//! `2k − 3` of its bars. The independent sets are those of a matroid, so a
+//! greedy pass over the bars in the caller's order finds a maximal
+//! independent set; the bars it rejects are the redundant ones. The pass is
+//! the pebble game of D. Jacobs and B. Hendrickson, *An algorithm for
+//! two-dimensional rigidity percolation: the pebble game* (J. Comput.
+//! Phys., 1997), implemented from the paper.
+//!
+//! Everything here is combinatorial: no floating point, the same answer on
+//! every platform.
+
+use std::collections::BTreeMap;
+
+/// Free pebbles a point starts with: its two freedoms in the plane.
+const PEBBLES_PER_POINT: u8 = 2;
+/// Pebbles that must sit on a bar's two ends for it to be independent:
+/// `l + 1` for the (2, `l` = 3) pebble game.
+const PEBBLES_TO_ACCEPT: u8 = 4;
+
+/// A bar names a point the framework does not have, or a point twice.
+#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
+#[non_exhaustive]
+pub enum RigidityError {
+    /// `bars[bar]` names `point`, but the framework has only `points` points.
+    #[error("bar {bar} names point {point}, but the framework has {points} points")]
+    PointOutOfRange {
+        /// Index of the bar in the caller's slice.
+        bar: usize,
+        /// The point it names.
+        point: usize,
+        /// The number of points in the framework.
+        points: usize,
+    },
+    /// `bars[bar]` joins `point` to itself.
+    #[error("bar {bar} joins point {point} to itself")]
+    SelfLoop {
+        /// Index of the bar in the caller's slice.
+        bar: usize,
+        /// The point at both of its ends.
+        point: usize,
+    },
+    /// The freedom count `2 × points` does not fit in a `usize`.
+    #[error("{points} points have more freedoms than a usize holds")]
+    TooManyPoints {
+        /// The number of points asked for.
+        points: usize,
+    },
+}
+
+/// The generic rigidity of a bar framework.
+///
+/// "Generic" means for points in general position: a framework this
+/// reports rigid can still flex at special positions (three collinear
+/// points), never the other way round.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct Rigidity {
+    /// The number of points in the framework.
+    pub points: usize,
+    /// Indices of the bars that are independent, ascending. The first
+    /// maximal independent set in the caller's order.
+    pub independent: Vec<usize>,
+    /// Indices of the bars that are redundant given the bars before them,
+    /// ascending. Each one could be removed without the framework gaining
+    /// a freedom.
+    pub redundant: Vec<usize>,
+    /// Remaining internal degrees of freedom: the freedoms of the points
+    /// minus those the independent bars remove, minus the motions of the
+    /// whole framework (2 for one point, 3 for two or more).
+    pub dof: usize,
+}
+
+impl Rigidity {
+    /// Whether the framework is generically rigid (no internal freedom).
+    pub fn is_rigid(&self) -> bool {
+        self.dof == 0
+    }
+
+    /// Whether the framework is rigid with no redundant bar: `2n − 3` bars
+    /// for `n ≥ 2` points, a Laman graph.
+    pub fn is_minimally_rigid(&self) -> bool {
+        self.is_rigid() && self.redundant.is_empty()
+    }
+}
+
+/// The generic rigidity of `points` points joined by `bars`, each bar a
+/// pair of point indices in `0..points`.
+///
+/// Bars may repeat (a repeat is redundant). Points no bar names are free
+/// and count toward [`Rigidity::dof`]. The result depends only on the
+/// input, the order of `bars` included: of several redundant bars that
+/// could be dropped, the later ones are named.
+///
+/// # Errors
+///
+/// [`RigidityError`] for a bar naming a point out of range or the same
+/// point twice, and for a point count whose freedoms overflow a `usize`.
+///
+/// # Example
+///
+/// ```
+/// // A square flexes: one internal freedom. Its diagonal makes it rigid.
+/// let square = [(0, 1), (1, 2), (2, 3), (3, 0)];
+/// assert_eq!(laman::rigidity(4, &square).unwrap().dof, 1);
+/// let braced = [(0, 1), (1, 2), (2, 3), (3, 0), (0, 2)];
+/// assert!(laman::rigidity(4, &braced).unwrap().is_minimally_rigid());
+/// ```
+pub fn rigidity(points: usize, bars: &[(usize, usize)]) -> Result<Rigidity, RigidityError> {
+    let freedoms = points
+        .checked_mul(usize::from(PEBBLES_PER_POINT))
+        .ok_or(RigidityError::TooManyPoints { points })?;
+
+    // The game runs over the points the bars name only, numbered in
+    // ascending order, so its memory follows the bars and not `points`.
+    let mut slot: BTreeMap<usize, usize> = BTreeMap::new();
+    for (bar, &(a, b)) in bars.iter().enumerate() {
+        for point in [a, b] {
+            if point >= points {
+                return Err(RigidityError::PointOutOfRange { bar, point, points });
+            }
+        }
+        if a == b {
+            return Err(RigidityError::SelfLoop { bar, point: a });
+        }
+        slot.insert(a, 0);
+        slot.insert(b, 0);
+    }
+    for (i, s) in slot.values_mut().enumerate() {
+        *s = i;
+    }
+
+    let mut game = PebbleGame::new(slot.len());
+    let mut independent = Vec::new();
+    let mut redundant = Vec::new();
+    for (bar, (a, b)) in bars.iter().enumerate() {
+        let (Some(&u), Some(&v)) = (slot.get(a), slot.get(b)) else {
+            // Every endpoint was given a slot above.
+            continue;
+        };
+        if game.insert(u, v) {
+            independent.push(bar);
+        } else {
+            redundant.push(bar);
+        }
+    }
+
+    let trivial = match points {
+        0 => 0,
+        1 => 2,
+        _ => 3,
+    };
+    // An independent set holds at most 2n − 3 bars, so this never saturates
+    // for n ≥ 2; it is written saturating so no input can make it panic.
+    let dof = freedoms
+        .saturating_sub(independent.len())
+        .saturating_sub(trivial);
+    Ok(Rigidity {
+        points,
+        independent,
+        redundant,
+        dof,
+    })
+}
+
+/// The (2,3) pebble game over points `0..n`.
+///
+/// Each point holds up to two free pebbles; each accepted bar is covered by
+/// one pebble of one of its ends and directed away from it (`out[x]` holds
+/// the far ends of the bars `x` covers). Ordered containers and a fixed
+/// search order keep every run identical.
+struct PebbleGame {
+    pebbles: Vec<u8>,
+    out: Vec<Vec<usize>>,
+}
+
+impl PebbleGame {
+    fn new(n: usize) -> Self {
+        Self {
+            pebbles: vec![PEBBLES_PER_POINT; n],
+            out: vec![Vec::new(); n],
+        }
+    }
+
+    /// Inserts the bar `u`–`v` if it is independent of the bars accepted so
+    /// far; returns whether it was.
+    fn insert(&mut self, u: usize, v: usize) -> bool {
+        while self.pebbles[u] < PEBBLES_PER_POINT && self.fetch(u, v) {}
+        while self.pebbles[v] < PEBBLES_PER_POINT && self.fetch(v, u) {}
+        if self.pebbles[u] + self.pebbles[v] < PEBBLES_TO_ACCEPT {
+            return false;
+        }
+        self.pebbles[u] -= 1;
+        self.out[u].push(v);
+        true
+    }
+
+    /// Brings one free pebble to `root` along a directed path that avoids
+    /// `held` (whose pebbles are being kept), reversing the path's bars.
+    /// Returns false when no free pebble is reachable.
+    fn fetch(&mut self, root: usize, held: usize) -> bool {
+        let n = self.pebbles.len();
+        let mut parent: Vec<Option<usize>> = vec![None; n];
+        let mut seen = vec![false; n];
+        seen[root] = true;
+        seen[held] = true;
+        let mut stack = vec![root];
+        let mut found = None;
+        'search: while let Some(x) = stack.pop() {
+            for &y in &self.out[x] {
+                if seen[y] {
+                    continue;
+                }
+                seen[y] = true;
+                parent[y] = Some(x);
+                if self.pebbles[y] > 0 {
+                    found = Some(y);
+                    break 'search;
+                }
+                stack.push(y);
+            }
+        }
+        let Some(found) = found else {
+            return false;
+        };
+        let mut y = found;
+        while let Some(x) = parent[y] {
+            self.reverse(x, y);
+            y = x;
+        }
+        self.pebbles[found] -= 1;
+        self.pebbles[root] += 1;
+        true
+    }
+
+    /// Turns the bar `x → y` into `y → x`: `y`'s pebble covers it now.
+    fn reverse(&mut self, x: usize, y: usize) {
+        if let Some(i) = self.out[x].iter().position(|&h| h == y) {
+            self.out[x].remove(i);
+            self.out[y].push(x);
+        }
+    }
+}

laman-0.0.1/crates/laman/tests/rigidity.rs

@@ -0,0 +1,148 @@
+//! The rigidity count against hand-counted frameworks and against Laman's
+//! condition checked by brute force over every subset of points.
+
+use laman::{RigidityError, rigidity};
+
+#[test]
+fn rigidity_triangle_is_minimally_rigid() {
+    let r = rigidity(3, &[(0, 1), (1, 2), (2, 0)]).unwrap();
+    assert_eq!(r.dof, 0);
+    assert!(r.is_minimally_rigid());
+}
+
+#[test]
+fn rigidity_square_has_one_freedom() {
+    let r = rigidity(4, &[(0, 1), (1, 2), (2, 3), (3, 0)]).unwrap();
+    assert_eq!(r.dof, 1);
+    assert!(r.redundant.is_empty());
+}
+
+#[test]
+fn rigidity_complete_four_names_its_last_bar_redundant() {
+    let bars = [(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)];
+    let r = rigidity(4, &bars).unwrap();
+    assert_eq!(r.dof, 0);
+    assert_eq!(r.independent, vec![0, 1, 2, 3, 4]);
+    assert_eq!(r.redundant, vec![5]);
+}
+
+#[test]
+fn rigidity_bowtie_hinges_at_its_shared_point() {
+    // Two triangles sharing point 2: rigid each, one rotation between them.
+    let bars = [(0, 1), (1, 2), (2, 0), (2, 3), (3, 4), (4, 2)];
+    let r = rigidity(5, &bars).unwrap();
+    assert_eq!(r.dof, 1);
+    assert!(r.redundant.is_empty());
+}
+
+#[test]
+fn rigidity_redundancy_is_local() {
+    // K4 (one redundant bar) hanging off a pendant point: the excess in K4
+    // does not hold the pendant, which keeps one freedom.
+    let bars = [(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3), (3, 4)];
+    let r = rigidity(5, &bars).unwrap();
+    assert_eq!(r.redundant, vec![5]);
+    assert_eq!(r.dof, 1);
+}
+
+#[test]
+fn rigidity_repeated_bar_is_redundant() {
+    let r = rigidity(2, &[(0, 1), (1, 0)]).unwrap();
+    assert_eq!(r.dof, 0);
+    assert_eq!(r.redundant, vec![1]);
+}
+
+#[test]
+fn rigidity_counts_free_points() {
+    assert_eq!(rigidity(0, &[]).unwrap().dof, 0);
+    assert_eq!(rigidity(1, &[]).unwrap().dof, 0);
+    assert_eq!(rigidity(2, &[]).unwrap().dof, 1);
+    // A triangle and two loose points: 2 × 2 freedoms of the loose points.
+    let r = rigidity(5, &[(0, 1), (1, 2), (2, 0)]).unwrap();
+    assert_eq!(r.dof, 4);
+}
+
+#[test]
+fn rigidity_refuses_bad_bars() {
+    assert_eq!(
+        rigidity(3, &[(0, 1), (1, 3)]),
+        Err(RigidityError::PointOutOfRange {
+            bar: 1,
+            point: 3,
+            points: 3
+        })
+    );
+    assert_eq!(
+        rigidity(3, &[(2, 2)]),
+        Err(RigidityError::SelfLoop { bar: 0, point: 2 })
+    );
+    assert_eq!(
+        rigidity(usize::MAX, &[]),
+        Err(RigidityError::TooManyPoints { points: usize::MAX })
+    );
+}
+
+#[test]
+fn rigidity_memory_follows_the_bars() {
+    // A huge point count with few bars: the game runs over the named points.
+    let n = usize::MAX / 2;
+    let r = rigidity(n, &[(0, n - 1), (n - 1, 7), (7, 0)]).unwrap();
+    assert_eq!(r.dof, 2 * n - 3 - 3);
+}
+
+/// Whether `bars` over `n` points satisfies Laman's sparsity condition:
+/// every subset of `k ≥ 2` points spans at most `2k − 3` bars.
+fn laman_sparse(n: usize, bars: &[(usize, usize)]) -> bool {
+    (0u32..1 << n).all(|subset| {
+        let k = subset.count_ones() as usize;
+        let inside = bars
+            .iter()
+            .filter(|(a, b)| subset & (1 << a) != 0 && subset & (1 << b) != 0)
+            .count();
+        k < 2 || inside <= 2 * k - 3
+    })
+}
+
+/// A small deterministic generator, so the corpus is the same every run.
+struct XorShift(u64);
+impl XorShift {
+    fn below(&mut self, m: usize) -> usize {
+        self.0 ^= self.0 << 13;
+        self.0 ^= self.0 >> 7;
+        self.0 ^= self.0 << 17;
+        (self.0 % m as u64) as usize
+    }
+}
+
+#[test]
+fn rigidity_matches_greedy_laman_sparsity() {
+    let mut rng = XorShift(0x5eed_1a3a_2026_1101);
+    for _ in 0..1000 {
+        let n = 2 + rng.below(6);
+        let m = rng.below(3 * n);
+        let bars: Vec<(usize, usize)> = (0..m)
+            .map(|_| {
+                let a = rng.below(n);
+                (a, (a + 1 + rng.below(n - 1)) % n)
+            })
+            .collect();
+
+        // The greedy basis by brute force: keep a bar when the kept set
+        // stays sparse with it.
+        let mut kept: Vec<(usize, usize)> = Vec::new();
+        let mut expected = Vec::new();
+        for (i, &bar) in bars.iter().enumerate() {
+            kept.push(bar);
+            if laman_sparse(n, &kept) {
+                expected.push(i);
+            } else {
+                kept.pop();
+            }
+        }
+
+        let r = rigidity(n, &bars).unwrap();
+        assert_eq!(r.independent, expected, "n = {n}, bars = {bars:?}");
+        assert_eq!(r.independent.len() + r.redundant.len(), m);
+        assert_eq!(r.dof, 2 * n - expected.len() - 3, "n = {n}, bars = {bars:?}");
+    }
+}

laman-0.0.1/crates/laman-py/Cargo.toml

@@ -0,0 +1,31 @@
+[package]
+name = "laman-py"
+description = "Laman: the Python binding (PyPI `laman`), a thin layer over the crate"
+# Published to PyPI as `laman`, never to crates.io (SEED.md §7).
+publish = false
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+repository.workspace = true
+
+[lib]
+name = "laman_py"
+# The cdylib is the extension module; the rlib keeps `cargo test` and clippy
+# working over the workspace.
+crate-type = ["cdylib", "rlib"]
+
+[features]
+# Set by maturin (`pyproject.toml`), never by a Rust build: an extension
+# module must not link libpython, a test binary must.
+extension-module = ["pyo3/extension-module"]
+
+[dependencies]
+laman.workspace = true
+
+# pyo3 does not build for wasm32-unknown-unknown, so the crate is empty there.
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+pyo3.workspace = true
+
+[lints]
+workspace = true

laman-0.0.1/crates/laman-py/src/lib.rs

@@ -0,0 +1,74 @@
+//! `laman-py`: the Python binding, the package `laman` on PyPI.
+//!
+//! A thin 1:1 layer over the `laman` crate; nothing here computes. The
+//! crate is `publish = false` on crates.io and empty on
+//! `wasm32-unknown-unknown`, where pyo3 does not build.
+#![forbid(unsafe_code)]
+#![cfg(not(target_arch = "wasm32"))]
+
+use pyo3::create_exception;
+use pyo3::exceptions::PyValueError;
+use pyo3::prelude::*;
+
+create_exception!(
+    laman,
+    RigidityError,
+    PyValueError,
+    "A bar names a point the framework does not have, or a point twice."
+);
+
+/// The generic rigidity of a bar framework (`laman::Rigidity`).
+#[pyclass(frozen, module = "laman", get_all)]
+pub struct Rigidity {
+    /// The number of points in the framework.
+    pub points: usize,
+    /// Indices of the independent bars, ascending.
+    pub independent: Vec<usize>,
+    /// Indices of the bars redundant given the bars before them, ascending.
+    pub redundant: Vec<usize>,
+    /// Remaining internal degrees of freedom.
+    pub dof: usize,
+}
+
+#[pymethods]
+impl Rigidity {
+    /// Whether the framework is generically rigid (no internal freedom).
+    fn is_rigid(&self) -> bool {
+        self.dof == 0
+    }
+
+    /// Whether the framework is rigid with no redundant bar.
+    fn is_minimally_rigid(&self) -> bool {
+        self.dof == 0 && self.redundant.is_empty()
+    }
+
+    fn __repr__(&self) -> String {
+        format!(
+            "Rigidity(points={}, dof={}, independent={:?}, redundant={:?})",
+            self.points, self.dof, self.independent, self.redundant
+        )
+    }
+}
+
+/// The generic rigidity of `points` points joined by `bars` (pairs of
+/// point indices). Raises `RigidityError` for a bar naming a point out of
+/// range or the same point twice.
+#[pyfunction]
+fn rigidity(points: usize, bars: Vec<(usize, usize)>) -> PyResult<Rigidity> {
+    let r = laman::rigidity(points, &bars).map_err(|e| RigidityError::new_err(e.to_string()))?;
+    Ok(Rigidity {
+        points: r.points,
+        independent: r.independent,
+        redundant: r.redundant,
+        dof: r.dof,
+    })
+}
+
+/// The extension module `laman._laman`, re-exported by `laman/__init__.py`.
+#[pymodule]
+fn _laman(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_function(wrap_pyfunction!(rigidity, m)?)?;
+    m.add_class::<Rigidity>()?;
+    m.add("RigidityError", m.py().get_type::<RigidityError>())?;
+    Ok(())
+}

laman-0.0.1/crates/laman-py/tests/test_rigidity.py

@@ -0,0 +1,30 @@
+"""The binding answers as the crate does; the counts themselves are tested in Rust."""
+
+import pytest
+
+import laman
+
+
+def test_triangle_is_minimally_rigid() -> None:
+    r = laman.rigidity(3, [(0, 1), (1, 2), (2, 0)])
+    assert r.dof == 0
+    assert r.is_minimally_rigid()
+
+
+def test_complete_four_names_its_last_bar() -> None:
+    bars = [(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]
+    r = laman.rigidity(4, bars)
+    assert r.is_rigid()
+    assert r.independent == [0, 1, 2, 3, 4]
+    assert r.redundant == [5]
+
+
+def test_square_flexes() -> None:
+    assert laman.rigidity(4, [(0, 1), (1, 2), (2, 3), (3, 0)]).dof == 1
+
+
+def test_bad_bar_raises() -> None:
+    with pytest.raises(laman.RigidityError, match="bar 1 names point 3"):
+        laman.rigidity(3, [(0, 1), (1, 3)])
+    with pytest.raises(ValueError):
+        laman.rigidity(3, [(2, 2)])

laman-0.0.1/crates/laman-py/tests/test_stubs.py

@@ -0,0 +1,8 @@
+"""The typed stubs match the extension module (mypy.stubtest) and type-check strictly."""
+
+import subprocess
+import sys
+
+
+def test_stubtest() -> None:
+    subprocess.run([sys.executable, "-m", "mypy.stubtest", "laman"], check=True)

laman-0.0.1/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["maturin>=1.7,<2"]
+build-backend = "maturin"
+
+[project]
+name = "laman"
+# maturin reads the version from Cargo.toml, which inherits the workspace's.
+dynamic = ["version"]
+description = "A deterministic 2D geometric constraint solver in pure Rust. Early release: the generic rigidity count of bar frameworks (Laman's theorem)"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT OR Apache-2.0" }
+keywords = ["constraint solver", "cad", "sketch", "geometry", "rigidity"]
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Rust",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Mathematics",
+    "Typing :: Typed",
+]
+
+[project.urls]
+Repository = "https://github.com/arris-labs/laman"
+
+[project.optional-dependencies]
+test = ["pytest>=8", "mypy>=1.18"]
+
+[tool.maturin]
+module-name = "laman._laman"
+features = ["extension-module"]
+manifest-path = "crates/laman-py/Cargo.toml"
+python-source = "python"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

laman-0.0.1/python/laman/__init__.py

@@ -0,0 +1,9 @@
+"""Laman: a deterministic 2D geometric constraint solver. A thin layer over the Rust crate.
+
+This early release holds the generic rigidity count of bar frameworks
+(Laman's theorem); the sketch solver is being built.
+"""
+
+from ._laman import Rigidity, RigidityError, rigidity
+
+__all__ = ["Rigidity", "RigidityError", "rigidity"]

laman-0.0.1/python/laman/_laman.pyi

@@ -0,0 +1,25 @@
+from collections.abc import Sequence
+from typing import final
+
+__all__ = ["Rigidity", "RigidityError", "rigidity"]
+
+class RigidityError(ValueError):
+    """A bar names a point the framework does not have, or a point twice."""
+
+@final
+class Rigidity:
+    """The generic rigidity of a bar framework."""
+
+    @property
+    def points(self) -> int: ...
+    @property
+    def independent(self) -> list[int]: ...
+    @property
+    def redundant(self) -> list[int]: ...
+    @property
+    def dof(self) -> int: ...
+    def is_rigid(self) -> bool: ...
+    def is_minimally_rigid(self) -> bool: ...
+
+def rigidity(points: int, bars: Sequence[tuple[int, int]]) -> Rigidity:
+    """The generic rigidity of `points` points joined by `bars`."""