groups · PermutationGroup¶

51 accepted declarations. Python and Rust forms, contracts, evidence, failure boundaries, and checked usages are kept together below.

Worked example¶

The complete checked program Construct S4 natively and inspect its stabilizer chain consequences uses this API directly.

# SPDX-License-Identifier: MIT
# Copyright (c) 2026 Benjamin Antieau and Deven Manam
"""Construct S4 natively and inspect its stabilizer chain consequences."""

from noether.groups import Permutation, PermutationGroup


def main() -> None:
    group = PermutationGroup.from_generators(
        4,
        [Permutation.from_images([1, 0, 2, 3]), Permutation.from_images([1, 2, 3, 0])],
    )
    assert group.order == 24
    assert group.is_transitive
    assert group.stabilizer(0).order == 6
    random = group.uniform_random_element(seed=2026)
    assert random.element in group
    print(f"|S4|={group.order}; |Stab(0)|={group.stabilizer(0).order}; sample={random.element}")


if __name__ == "__main__":
    main()

Run it with .venv/bin/python examples/19_permutation_groups.py.

`groups.PermutationGroup`¶

A permutation group given by generators, carrying its BSGS.

Detailed contract

A permutation group given by generators, carrying its BSGS.

Construct via PermGroup.from_generators (deterministic Schreier–Sims) or PermGroup.from_generators_randomized (Monte-Carlo BSGS, verified by a deterministic final sweep, so an unverified probabilistic result is never returned). The constructor computes the base, strong generating set, stabilizer chain, per-level transversals, and group order; every query downstream is a method on this object and runs in constant-time-per-step.

PythonRust

class PermutationGroup

noether::groups::PermutationGroup · Direct Rust declaration

pub struct PermutationGroup { /* private fields */ }

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	attached / bounded
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: examples/19_permutation_groups.py:5 · examples/19_permutation_groups.py:9 · examples/20_conjugacy_classes.py:5 · examples/20_conjugacy_classes.py:9 · examples/34_finite_group_cohomology.py:10 · examples/34_finite_group_cohomology.py:5

`groups.PermutationGroup.contains`¶

Return bool(key in self).

Detailed contract

true iff g lies in the group. Sifts g and checks the residue is the identity.

PythonRust

(self, element: Permutation) -> bool

noether::groups::PermutationGroup::contains · Direct Rust declaration

pub fn contains(&self, g: &Perm) -> Result<bool, GroupError>
fn contains(&self, value: &Self::Element) -> Result<bool, GroupError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: validation/unit/infra/test_discovery.py:200

`groups.PermutationGroup.abelian_invariant_factors`¶

Canonical invariant factors when this concrete group is finite abelian.

PythonRust

(self) -> list[int]

noether::groups::PermutationGroup::abelian_invariant_factors · Direct Rust declaration

fn abelian_invariant_factors( &self, ) -> Result<Vec<Integer>, FiniteAbelianInvariantError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: validation/unit/homalg/test_finite_group_cohomology.py:32 · validation/unit/homalg/test_finite_group_cohomology.py:53

`groups.PermutationGroup.abelianization_invariant_factors`¶

Canonical invariant factors of this finite group's abelianization.

PythonRust

(self) -> list[int]

noether::groups::PermutationGroup::abelianization_invariant_factors · Direct Rust declaration

fn abelianization_invariant_factors( &self, ) -> Result<Vec<Integer>, FiniteAbelianInvariantError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: validation/unit/homalg/test_finite_group_cohomology.py:56 · validation/corpus/groups/oscar-four-cube-automorphisms.py:20

`groups.PermutationGroup.base`¶

The base — the ordered list of base points the stabilizer chain stabilises one level at a time.

Detailed contract

The base — the ordered list of base points the stabilizer chain stabilises one level at a time. Empty list[int] for the trivial group.

The base, in order — the points the stabilizer chain stabilises one level at a time. Empty for the trivial group.

PythonRust

(self) -> list[int]

noether::groups::PermutationGroup::base · Direct Rust declaration

pub fn base(&self) -> Vec<u32>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	attached / bounded
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: validation/unit/commalg/test_acceptance_workload.py:59 · validation/unit/commalg/test_acceptance_workload.py:60 · validation/unit/commalg/test_base_change.py:112 · validation/unit/commalg/test_base_change.py:113 · validation/unit/commalg/test_polynomial_ideal_facade.py:398 · validation/unit/commalg/test_polynomial_ideal_facade.py:399

`groups.PermutationGroup.base_and_strong_generating_set`¶

The base and strong generating set as a (list[int], list[Permutation]) pair, useful for callers that want the BSGS without constructing the full PermGroup API on it twice.

Detailed contract

The base and strong generating set as a (list[int], list[Permutation]) pair, useful for callers that want the BSGS without constructing the full PermGroup API on it twice.

PythonRust

(degree: int, generators: Sequence[Permutation]) -> tuple[list[int], list[Permutation]]

noether::groups::PermutationGroup · Python projection

Python projection convenience over this Rust mathematical type

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: validation/parity/_noether_bsgs.py:146 · validation/parity/m1_bsgs.py:28 · validation/parity/m1_bsgs.py:330

`groups.PermutationGroup.complete_abelian_integral_cohomology`¶

Complete closed-form H*(BG; Z) for a supported finite abelian group.

PythonRust

(self) -> FiniteAbelianGroupIntegralCohomologyPresentation

noether::groups::PermutationGroup::complete_abelian_integral_cohomology · Direct Rust declaration

fn complete_abelian_integral_cohomology( &self, ) -> Result<FiniteAbelianGroupIntegralCohomologyPresentation, FiniteAbelianGroupCohomologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: validation/unit/homalg/test_finite_group_cohomology.py:108

`groups.PermutationGroup.complete_abelian_modular_cohomology`¶

Complete closed-form H*(BG; F_p) for a finite abelian group.

PythonRust

(self, field: FiniteField) -> FiniteAbelianGroupCohomologyPresentation

noether::groups::PermutationGroup::complete_abelian_modular_cohomology · Direct Rust declaration

fn complete_abelian_modular_cohomology( &self, field: FiniteField, ) -> Result<FiniteAbelianGroupCohomologyPresentation, FiniteAbelianGroupCohomologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: validation/unit/homalg/test_finite_group_cohomology.py:33 · validation/unit/homalg/test_finite_group_cohomology.py:55

`groups.PermutationGroup.complete_cyclic_integral_cohomology`¶

Complete closed-form H*(BG; Z) for a finite cyclic group.

PythonRust

(self) -> FiniteCyclicGroupIntegralCohomologyPresentation

noether::groups::PermutationGroup::complete_cyclic_integral_cohomology · Direct Rust declaration

fn complete_cyclic_integral_cohomology( &self, ) -> Result<FiniteCyclicGroupIntegralCohomologyPresentation, FiniteCyclicGroupIntegralCohomologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: validation/unit/homalg/test_finite_group_cohomology.py:70 · validation/unit/homalg/test_finite_group_cohomology.py:97

`groups.PermutationGroup.conjugacy_classes`¶

Exact conjugacy classes, ordered by their canonical representatives.

Detailed contract

Exact conjugacy classes, ordered by their canonical representatives.

The native correctness floor enumerates groups of order at most one million and fails before returning a partial result above that bound.

Enumerate every conjugacy class exactly for a bounded-order group. The result order is deterministic: representatives and lazily materialized members use lexicographic image-vector order. If the group order exceeds [CONJUGACY_ENUMERATION_CAP], this returns a typed error before materializing any elements.

PythonRust

(self) -> list[ConjugacyClass]

noether::groups::PermutationGroup::conjugacy_classes · Direct Rust declaration

pub fn conjugacy_classes(&self) -> Result<Vec<ConjugacyClass>, GroupError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: examples/20_conjugacy_classes.py:13 · validation/unit/groups/test_acceptance_workload.py:167 · validation/unit/groups/test_acceptance_workload.py:78 · validation/unit/groups/test_conjugacy.py:115 · validation/unit/groups/test_conjugacy.py:34 · validation/unit/groups/test_conjugacy.py:49

`groups.PermutationGroup.conjugating_element`¶

A conjugating element g with selfᵍ = other (i.e.

Detailed contract

A conjugating element g with selfᵍ = other (i.e. g⁻¹ · self · g = other), or None if the two groups are not conjugate in S_n. The witness is sift-verified before it is returned. Raises ValueError on a degree mismatch, OverflowError if the backtrack exceeds its search budget.

A conjugating element g with selfᵍ = other (i.e. g⁻¹ · self · g = other as groups), or None if self and other are not conjugate in S_n. The returned witness is sift-verified: selfᵍ = other holds exactly. §Errors GroupError::DegreeMismatch if self and other act on different degrees; GroupError::SearchBudgetExceeded if the backtrack exceeds its node cap. use perm_core::{PermGroup, Perm}; // ⟨(0 1)⟩ and ⟨(2 3)⟩ are conjugate transpositions in S_4. let h = PermGroup::from_generators(4, &[Perm::from_images(&[1, 0, 2, 3]).unwrap()]).unwrap(); let k = PermGroup::from_generators(4, &[Perm::from_images(&[0, 1, 3, 2]).unwrap()]).unwrap(); assert!(h.conjugating_element(&k).unwrap().is_some());

PythonRust

(self, other: PermutationGroup) -> Permutation | None

noether::groups::PermutationGroup::conjugating_element · Direct Rust declaration

pub fn conjugating_element( &self, other: &PermGroup, ) -> Result<Option<Perm>, GroupError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: validation/unit/groups/test_acceptance_workload.py:105 · validation/corpus/groups/simplicial-torus-automorphisms.py:36

`groups.PermutationGroup.contains`¶

True iff g lies in the group.

Detailed contract

True iff g lies in the group. Sifts g down the stabilizer chain and checks the residue is the identity. Raises ValueError on a degree mismatch.

true iff g lies in the group. Sifts g and checks the residue is the identity.

PythonRust

(self, element: Permutation) -> bool

noether::groups::PermutationGroup::contains · Direct Rust declaration

pub fn contains(&self, g: &Perm) -> Result<bool, GroupError>
fn contains(&self, value: &Self::Element) -> Result<bool, GroupError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: examples/38_exact_linear_systems.py:73 · validation/unit/commalg/test_local_algebra.py:63 · validation/unit/commalg/test_prime_localization.py:50 · validation/unit/commalg/test_prime_localization.py:55 · validation/unit/groups/test_acceptance_workload.py:56 · validation/unit/groups/test_permutation_group_facade.py:81

`groups.PermutationGroup.degree`¶

The degree — the size of the permutation domain 0..degree.

Detailed contract

The degree — the size of the underlying domain 0..degree.

PythonRust

(self) -> int

noether::groups::PermutationGroup::degree · Direct Rust declaration

pub fn degree(&self) -> usize

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	attached / bounded
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: examples/14_weighted_polynomials.py:16 · examples/14_weighted_polynomials.py:18 · examples/15_groebner_twisted_cubic.py:15 · examples/15_groebner_twisted_cubic.py:28 · examples/31_local_fields_and_precision.py:37 · examples/33_simplicial_cohomology_operations.py:26

`groups.PermutationGroup.double_coset_triangle`¶

Lower-triangular exact double-coset table for several subgroups.

Detailed contract

Exact lower-triangular double-coset table for several subgroups.

PythonRust

(self, subgroups: Sequence[PermutationGroup]) -> list[list[list[DoubleCoset]]]

noether::groups::PermutationGroup::double_coset_triangle · Direct Rust declaration

pub fn double_coset_triangle( &self, subgroups: &[PermGroup], ) -> Result<Vec<Vec<Vec<DoubleCoset>>>, GroupError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: validation/unit/groups/test_acceptance_workload.py:151

`groups.PermutationGroup.double_cosets`¶

Exact double cosets of two literal subgroups.

Detailed contract

Exact double cosets of two literal subgroups of self.

PythonRust

(self, left: PermutationGroup, right: PermutationGroup) -> list[DoubleCoset]

noether::groups::PermutationGroup::double_cosets · Direct Rust declaration

pub fn double_cosets( &self, left: &PermGroup, right: &PermGroup, ) -> Result<Vec<DoubleCoset>, GroupError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: validation/unit/groups/test_acceptance_workload.py:141 · validation/unit/infra/test_discovery.py:115 · validation/bench/magma_release.py:1571

`groups.PermutationGroup.embeds_up_to_conjugacy`¶

A witness g with selfᵍ ≤ over (some S_n-conjugate of self is a subgroup of over), or None.

Detailed contract

A witness g with selfᵍ ≤ over (some S_n-conjugate of self is a subgroup of over), or None. The witness is verified before it is returned. Raises ValueError on a degree mismatch, OverflowError on an exhausted search budget.

A witness g with selfᵍ ≤ over (some S_n-conjugate of self is a subgroup of over), or None. The returned witness is verified: every generator of self, conjugated by g, lies in over. §Errors GroupError::DegreeMismatch on a degree mismatch; GroupError::SearchBudgetExceeded on an exhausted budget. use perm_core::{PermGroup, Perm}; // ⟨(0 1)⟩ embeds (up to conjugacy) into S_3. let h = PermGroup::from_generators(3, &[Perm::from_images(&[1, 0, 2]).unwrap()]).unwrap(); let s3 = PermGroup::from_generators( 3, &[Perm::from_images(&[1, 0, 2]).unwrap(), Perm::from_images(&[1, 2, 0]).unwrap()], ).unwrap(); assert!(h.embeds_up_to_conjugacy(&s3).unwrap().is_some());

PythonRust

(self, over: PermutationGroup) -> Permutation | None

noether::groups::PermutationGroup::embeds_up_to_conjugacy · Direct Rust declaration

pub fn embeds_up_to_conjugacy( &self, over: &PermGroup, ) -> Result<Option<Perm>, GroupError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: validation/unit/groups/test_acceptance_workload.py:106

`groups.PermutationGroup.from_generators`¶

Construct a permutation group on 0..degree from a generator list, running deterministic Schreier–Sims.

Detailed contract

Construct a permutation group on 0..degree from a generator list, running deterministic Schreier–Sims.

Raises ValueError on a degree mismatch or a non-permutation generator.

Construct a permutation group on 0..degree from a generator list, running deterministic Schreier–Sims to its BSGS. §Errors GroupError::DegreeMismatch if any generator’s length is not degree. GroupError::NotAPermutation if any generator is not a permutation of 0..degree.

PythonRust

(degree: int, generators: Sequence[Permutation]) -> PermutationGroup

noether::groups::PermutationGroup::from_generators · Direct Rust declaration

pub fn from_generators( degree: usize, generators: &[Perm], ) -> Result<PermGroup, GroupError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Dispatch / backing	perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1
Failures	degree mismatch, non-permutation generator

Executable usage: examples/19_permutation_groups.py:9 · examples/20_conjugacy_classes.py:9 · examples/30_modules_and_resolutions.py:26 · examples/34_finite_group_cohomology.py:10 · examples/38_exact_linear_systems.py:56 · validation/unit/groups/test_acceptance_workload.py:122

Example

from noether.groups import Permutation, PermutationGroup
transposition = Permutation.from_images([1, 0, 2])
cycle = Permutation.from_images([1, 2, 0])
result = PermutationGroup.from_generators(3, [transposition, cycle])
assert result.order == 6

`groups.PermutationGroup.from_generators_randomized`¶

Construct via the verified randomized Schreier–Sims variant.

Detailed contract

Construct via the verified randomized Schreier–Sims variant.

Sims-style product replacement seeded with seed supplies random group elements; the chain stops growing after stabilize consecutive sift-to-identity events; the result is then verified by the deterministic Schreier-generator sweep. The seed is recorded on the result so the build is reproducible.

Construct via the randomized, verified Schreier–Sims variant. Internal Sims-style product replacement supplies random group elements; we sift each into the current chain, extend the chain on a non-trivial residue, and stop once stabilize random sifts in a row come back as the identity. The result is then verified by the deterministic Schreier-generator sweep — any sift that fails extends the chain. The verified output is returned; an unverified probabilistic result is never returned. The public seed is expanded by perm-core’s fixed mapping into a ChaCha20 seed, so the build is deterministic across dependency upgrades as well as within one binary.

PythonRust

(degree: int, generators: Sequence[Permutation], seed: int, stabilize: int) -> PermutationGroup

noether::groups::PermutationGroup::from_generators_randomized · Direct Rust declaration

pub fn from_generators_randomized( degree: usize, generators: &[Perm], seed: u64, stabilize: u32, ) -> Result<PermGroup, GroupError>

Contract	Value
Guarantee	checked deterministic result
Determinism	seeded
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: validation/unit/groups/test_acceptance_workload.py:97

`groups.PermutationGroup.generators`¶

The original generators, in input order, as a list[ Permutation].

Detailed contract

The original generators, in input order, as a list[ Permutation].

The original generators, in input order.

PythonRust

(self) -> list[Permutation]

noether::groups::PermutationGroup::generators · Direct Rust declaration

pub fn generators(&self) -> &[Perm]

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	attached / bounded
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: examples/14_weighted_polynomials.py:11 · examples/15_groebner_twisted_cubic.py:11 · examples/15_groebner_twisted_cubic.py:19 · examples/17_weighted_power_series.py:15 · examples/18_finite_field_schemes.py:12 · examples/30_modules_and_resolutions.py:20

`groups.PermutationGroup.group_order`¶

|G| as a Python int.

Detailed contract

|G| as a Python int. Conversion through decimal text preserves arbitrarily large orders without imposing a Rust primitive-integer limit.

PythonRust

(degree: int, generators: Sequence[Permutation]) -> int

noether::groups::PermutationGroup · Python projection

Python projection convenience over this Rust mathematical type

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: validation/unit/groups/test_permutation_group_facade.py:26 · validation/unit/homalg/test_finite_group_cohomology.py:176 · validation/parity/m1_bsgs.py:31 · validation/parity/m1_bsgs.py:330

`groups.PermutationGroup.identity`¶

The identity element in this permutation action.

PythonRust

(self) -> Permutation

noether::groups::PermutationGroup::identity · Direct Rust declaration

fn identity(&self) -> Self::Element

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	attached / bounded
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: examples/01_bezout_certificates.py:10 · examples/01_bezout_certificates.py:12 · examples/01_bezout_certificates.py:14 · examples/01_bezout_certificates.py:9 · examples/02_ball_arithmetic.py:3 · examples/distributed/f2_linear_algebra.py:20

`groups.PermutationGroup.integral_cohomology`¶

Compute the exact integral cohomology ring through max_degree.

PythonRust

(self, max_degree: int) -> FiniteGroupIntegralCohomologyTruncation

noether::groups::PermutationGroup::integral_cohomology · Direct Rust declaration

fn integral_cohomology( &self, max_degree: usize, ) -> Result<FiniteGroupIntegralCohomologyTruncation, FiniteGroupIntegralCohomologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: validation/unit/homalg/test_finite_group_cohomology.py:58 · validation/unit/infra/test_discovery.py:114 · validation/unit/topology/test_eilenberg_maclane.py:54 · validation/unit/topology/test_eilenberg_maclane.py:73

`groups.PermutationGroup.intersection`¶

Literal intersection with another group on the same point set.

Detailed contract

Literal intersection with another subgroup of the same symmetric group. The result acts on the same point set and contains exactly the permutations lying in both inputs. Exact generator containment returns a known contained input directly; otherwise the smaller input is enumerated, subject to SUBGROUP_ENUMERATION_CAP. §Errors GroupError::DegreeMismatch for different permutation domains; GroupError::EnumerationLimitExceeded above the exact native cap; construction or membership errors from the permutation-group kernel.

PythonRust

(self, other: PermutationGroup) -> PermutationGroup

noether::groups::PermutationGroup::intersection · Direct Rust declaration

pub fn intersection(&self, other: &PermGroup) -> Result<PermGroup, GroupError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: examples/37_complete_intersection_theory.py:3 · examples/39_kahler_differentials.py:37 · validation/unit/commalg/test_intersection_theory.py:100 · validation/unit/commalg/test_intersection_theory.py:102 · validation/unit/commalg/test_intersection_theory.py:3 · validation/unit/commalg/test_monomial_ideal_facade.py:33

`groups.PermutationGroup.inverse`¶

Checked inverse of an element of this group.

PythonRust

(self, value: Permutation) -> Permutation

noether::groups::PermutationGroup::inverse · Direct Rust declaration

fn inverse(&self, value: &Self::Element) -> Result<Self::Element, GroupError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	attached / bounded
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: examples/distributed/f2_linear_algebra.py:37 · examples/distributed/f2_linear_algebra.py:39 · validation/unit/commalg/test_context_tower_workload.py:121 · validation/unit/commalg/test_context_tower_workload.py:122 · validation/unit/commalg/test_context_tower_workload.py:75 · validation/unit/commalg/test_context_tower_workload.py:77

`groups.PermutationGroup.is_nilpotent`¶

Whether the group is nilpotent, computed from its lower central series.

PythonRust

(self) -> bool

noether::groups::PermutationGroup · Python projection

Python projection convenience over this Rust mathematical type

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: validation/unit/groups/test_permutation_group_facade.py:30 · validation/parity/groups/test_perm_core_gap_parity.py:118 · validation/bench/magma_release.py:1545 · validation/corpus/groups/degree-four-permutation-actions.py:26

`groups.PermutationGroup.is_perfect`¶

Whether the group equals its derived subgroup.

PythonRust

(self) -> bool

noether::groups::PermutationGroup · Python projection

Python projection convenience over this Rust mathematical type

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: validation/unit/groups/test_permutation_group_facade.py:31 · validation/unit/homalg/test_module_facade.py:508 · validation/parity/groups/test_perm_core_gap_parity.py:119 · validation/bench/macaulay2_derived.py:490 · validation/bench/magma_release.py:1546 · validation/corpus/groups/degree-four-permutation-actions.py:27

`groups.PermutationGroup.is_solvable`¶

Whether the group is solvable, computed from its derived series.

PythonRust

(self) -> bool

noether::groups::PermutationGroup · Python projection

Python projection convenience over this Rust mathematical type

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: validation/unit/groups/test_permutation_group_facade.py:29 · validation/parity/groups/test_perm_core_gap_parity.py:117 · validation/bench/magma_release.py:1544 · validation/corpus/groups/degree-four-permutation-actions.py:25 · validation/corpus/groups/oscar-four-cube-automorphisms.py:19

`groups.PermutationGroup.is_transitive`¶

Whether this action has one orbit.

Detailed contract

Whether this action has one orbit. The empty action is not transitive.

PythonRust

(self) -> bool

noether::groups::PermutationGroup · Python projection

Python projection convenience over this Rust mathematical type

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: examples/19_permutation_groups.py:14 · validation/unit/groups/test_permutation_group_facade.py:28 · validation/unit/infra/test_discovery.py:202 · validation/parity/groups/test_perm_core_gap_parity.py:116 · validation/corpus/groups/degree-four-permutation-actions.py:24 · validation/corpus/groups/hurwitz-degree-nine-generating-triple.py:22

`groups.PermutationGroup.iterate_elements`¶

A lazy odometer iterator over every group element.

Detailed contract

A lazy odometer iterator over every group element. Each iteration yields a fresh Permutation. The total number of yields equals order.

PythonRust

(self) -> Iterator[Permutation]

noether::groups::PermutationGroup · Python projection

Python projection convenience over this Rust mathematical type

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: validation/unit/groups/test_acceptance_workload.py:93 · validation/unit/infra/test_discovery.py:116 · validation/parity/_noether_bsgs.py:99 · validation/parity/m1_bsgs.py:333 · validation/parity/m1_bsgs.py:54 · validation/corpus/groups/lr-ray-symmetry-group.py:47

`groups.PermutationGroup.modular_cohomology`¶

Compute the exact mod-p cohomology ring through max_degree.

PythonRust

(self, prime: int, max_degree: int) -> FiniteGroupCohomologyTruncation

noether::groups::PermutationGroup::modular_cohomology · Direct Rust declaration

fn modular_cohomology( &self, prime: u64, max_degree: usize, ) -> Result<FiniteGroupCohomologyTruncation, FiniteGroupCohomologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: examples/34_finite_group_cohomology.py:11 · validation/unit/homalg/test_finite_group_cohomology.py:124 · validation/unit/homalg/test_finite_group_cohomology.py:139 · validation/unit/homalg/test_finite_group_cohomology.py:147 · validation/unit/homalg/test_finite_group_cohomology.py:168 · validation/unit/homalg/test_finite_group_cohomology.py:181

`groups.PermutationGroup.multiply`¶

Checked multiplication of two elements of this group.

PythonRust

(self, left: Permutation, right: Permutation) -> Permutation

noether::groups::PermutationGroup::multiply · Direct Rust declaration

fn multiply( &self, a: &Self::Element, b: &Self::Element, ) -> Result<Self::Element, GroupError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	attached / bounded
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: examples/05_sparse_exact_operators.py:3 · validation/unit/commalg/test_polynomial_ideal_facade.py:136 · validation/unit/commalg/test_polynomial_ideal_facade.py:137 · validation/unit/commalg/test_polynomial_ideal_facade.py:138 · validation/unit/commalg/test_polynomial_ideal_facade.py:139 · validation/unit/commalg/test_polynomial_ideal_facade.py:142

`groups.PermutationGroup.normalizer`¶

The normalizer of h inside self, N_self(h) = { g ∈ self : hᵍ = h }, as a PermGroup.

Detailed contract

The normalizer of h inside self, N_self(h) = { g ∈ self : hᵍ = h }, as a PermGroup. Raises ValueError on a degree mismatch.

The normalizer of h inside self, N_self(h) = { g ∈ self : hᵍ = h }. §Errors GroupError::DegreeMismatch if self and h act on different degrees; GroupError::SearchBudgetExceeded on an exhausted budget.

PythonRust

(self, subgroup: PermutationGroup) -> PermutationGroup

noether::groups::PermutationGroup::normalizer · Direct Rust declaration

pub fn normalizer(&self, h: &PermGroup) -> Result<PermGroup, GroupError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: validation/unit/groups/test_acceptance_workload.py:73 · validation/unit/groups/test_acceptance_workload.py:74 · validation/unit/groups/test_acceptance_workload.py:75 · validation/unit/groups/test_acceptance_workload.py:76 · validation/unit/infra/test_magma_release_protocol.py:190 · validation/unit/infra/test_magma_release_protocol.py:191

`groups.PermutationGroup.normalizer_in_symmetric`¶

The normalizer of self in the full symmetric group, N_{S_n}(self), returned as a PermGroup.

Detailed contract

The normalizer of self in the full symmetric group, N_{S_n}(self), returned as a PermGroup.

The normalizer of self in the full symmetric group, N_{S_n}(self). §Errors GroupError::SearchBudgetExceeded on an exhausted budget. use perm_core::{PermGroup, Perm}; // N_{S_3}(⟨(0 1 2)⟩) = S_3, order 6. let c3 = PermGroup::from_generators(3, &[Perm::from_images(&[1, 2, 0]).unwrap()]).unwrap(); assert_eq!(c3.normalizer_in_symmetric().unwrap().order(), perm_core::BigUInt::from(6u64));

PythonRust

(self) -> PermutationGroup

noether::groups::PermutationGroup::normalizer_in_symmetric · Direct Rust declaration

pub fn normalizer_in_symmetric(&self) -> Result<PermGroup, GroupError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: validation/unit/groups/test_acceptance_workload.py:73 · validation/parity/groups/test_perm_core_gap_parity.py:120

`groups.PermutationGroup.orbit`¶

The orbit of point under the full group, returned as list[int] in BFS-from-point order.

Detailed contract

The orbit of point under the full group, returned as list[int] in BFS-from-point order. Raises ValueError if point >= degree.

The orbit of point under the full group, in BFS-from- point discovery order. §Errors GroupError::DegreeMismatch if point >= degree.

PythonRust

(self, point: int) -> list[int]

noether::groups::PermutationGroup::orbit · Direct Rust declaration

pub fn orbit(&self, point: u32) -> Result<Vec<u32>, GroupError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: examples/20_conjugacy_classes.py:3 · validation/unit/groups/test_acceptance_workload.py:125 · validation/unit/groups/test_acceptance_workload.py:126 · validation/unit/groups/test_acceptance_workload.py:127 · validation/unit/groups/test_acceptance_workload.py:128 · validation/unit/groups/test_acceptance_workload.py:129

`groups.PermutationGroup.orbit_of_subset`¶

Exact orbit of one subset under the induced set action.

Detailed contract

Exact orbit of one set of points under the induced set action.

PythonRust

(self, points: Sequence[int]) -> SubsetOrbit

noether::groups::PermutationGroup::orbit_of_subset · Direct Rust declaration

pub fn orbit_of_subset(&self, subset: &[u32]) -> Result<SubsetOrbit, GroupError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: validation/unit/groups/test_acceptance_workload.py:134 · validation/corpus/groups/lr-ray-symmetry-group.py:56

`groups.PermutationGroup.orbit_stabilizer`¶

The (orbit, stabilizer) pair of point under G.

Detailed contract

The (orbit, stabilizer) pair of point under G. Returns an [OrbitStabilizer] carrying the orbit (list[int]) and the stabilizer (PermGroup).

The (orbit, stabilizer) pair of point under G. The orbit-stabilizer identity |orbit| * |stab| = |G| is an algebraic-invariant check exercised by the test suite.

PythonRust

(self, point: int) -> OrbitStabilizer

noether::groups::PermutationGroup::orbit_stabilizer · Direct Rust declaration

pub fn orbit_stabilizer( &self, point: u32, ) -> Result<OrbitStabilizer, GroupError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: validation/unit/groups/test_acceptance_workload.py:43 · validation/unit/groups/test_acceptance_workload.py:44 · validation/unit/groups/test_acceptance_workload.py:45 · validation/parity/m1_bsgs.py:332 · validation/parity/m1_bsgs.py:45 · validation/corpus/groups/igraph-complete-five-automorphisms.py:26

`groups.PermutationGroup.orbits_on_pairs`¶

Exact orbit partition of unordered pairs of distinct points.

PythonRust

(self) -> list[SubsetOrbit]

noether::groups::PermutationGroup::orbits_on_pairs · Direct Rust declaration

pub fn orbits_on_pairs(&self) -> Result<Vec<SubsetOrbit>, GroupError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: validation/unit/groups/test_acceptance_workload.py:124

`groups.PermutationGroup.orbits_on_subsets`¶

Exact orbit partition of all subsets with the requested cardinality.

Detailed contract

Exact orbit partition of all subsets of a fixed cardinality.

PythonRust

(self, size: int) -> list[SubsetOrbit]

noether::groups::PermutationGroup::orbits_on_subsets · Direct Rust declaration

pub fn orbits_on_subsets( &self, size: usize, ) -> Result<Vec<SubsetOrbit>, GroupError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

`groups.PermutationGroup.order`¶

|G| as a Python int — computed once at construction as the product of the transversal lengths.

Detailed contract

|G| as a Python int — computed once at construction as the product of the transversal lengths. Returned as a string the Python side parses to int, since the order can exceed any primitive integer (e.g. |S_512| is ~1170 digits).

|G|, computed once at construction as the product of the transversal lengths.

PythonRust

(self) -> int

noether::groups::PermutationGroup::order · Direct Rust declaration

pub fn order(&self) -> BigUInt
fn order(&self) -> Integer

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	attached / bounded
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: examples/11_qadic_witt_vectors.py:14 · examples/12_number_field_ideals.py:13 · examples/12_number_field_ideals.py:14 · examples/12_number_field_ideals.py:17 · examples/15_groebner_twisted_cubic.py:18 · examples/19_permutation_groups.py:13

`groups.PermutationGroup.pair_orbits`¶

Compact exact double-coset reduction of point pairs.

Detailed contract

Compact double-coset reduction of pairs between two point orbits.

PythonRust

(self, left_seed: int, right_seed: int) -> list[PairOrbit]

noether::groups::PermutationGroup::pair_orbits · Direct Rust declaration

pub fn pair_orbits( &self, left_seed: u32, right_seed: u32, ) -> Result<Vec<PairOrbit>, GroupError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: validation/unit/groups/test_acceptance_workload.py:124 · validation/unit/groups/test_acceptance_workload.py:125 · validation/unit/groups/test_acceptance_workload.py:126 · validation/unit/groups/test_acceptance_workload.py:127 · validation/unit/groups/test_acceptance_workload.py:128 · validation/unit/groups/test_acceptance_workload.py:135

`groups.PermutationGroup.pointwise_stabilizer`¶

The pointwise stabilizer of points in G.

Detailed contract

The pointwise stabilizer of points in G. Returns a new PermGroup (the stabilizer itself, with its own BSGS pre-computed). Raises ValueError if any points entry is >= degree.

The point stabilizer of points (jointly) in G. The result is itself a PermGroup with its own pre-computed chain. Fast-path: when points is a prefix of the existing base, the chain we want is just the suffix of self’s chain starting after that prefix — no Schreier–Sims rerun, no schreier-generator enumeration. Otherwise we fall back to the general path: rebuild from Schreier generators, point by point.

PythonRust

(self, points: Sequence[int]) -> PermutationGroup

noether::groups::PermutationGroup::pointwise_stabilizer · Direct Rust declaration

pub fn pointwise_stabilizer( &self, points: &[u32], ) -> Result<PermGroup, GroupError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: validation/unit/groups/test_acceptance_workload.py:42 · validation/parity/_noether_bsgs.py:55 · validation/parity/_noether_bsgs.py:72 · validation/parity/_noether_bsgs.py:90 · validation/parity/m1_bsgs.py:332 · validation/parity/m1_bsgs.py:44

`groups.PermutationGroup.schreier_generators`¶

The Schreier generators of Stab_G(point).

Detailed contract

The Schreier generators of Stab_G(point). Returns list[SchreierGenerator], each carrying the coset index, generator index, and the Schreier-generator permutation itself.

The Schreier generators of Stab_G(point) — g_i * s_j * g_{(i,s_j)}^{-1} for every coset rep g_i and every generator s_j, where g_{(i,s_j)} is the rep of the image of orbit[i] under s_j. Per Schreier’s lemma the raw multiset (|orbit| * |gens| entries minus trivials) generates the stabilizer; most of those generators are redundant. We sift each candidate against an incremental sub-chain for the emerging stabilizer and keep only candidates whose sift residue is non-trivial (i.e. that actually enlarge the subgroup). Output cardinality is then on the order of the sub-chain’s strong-generator count rather than |orbit| * |gens|. The retained (coset_index, generator_index, perm) is the original Schreier generator, not the sift residue, so the metadata stays faithful to the construction. Early-termination optimisation: the stabilizer has known order |G| / |orbit| (orbit–stabilizer), so once the sub-chain’s product of transversal lengths matches that, no remaining candidate can contribute and we return immediately. This is what turns the cost from O(|orbit| * |gens|) candidate products into O(rank-of-stabilizer) on groups with small stabilizers. The returned set always generates Stab_G(point) (the parity invariant == Stab_G(point) is preserved).

PythonRust

(self, point: int) -> list[SchreierGenerator]

noether::groups::PermutationGroup::schreier_generators · Direct Rust declaration

pub fn schreier_generators( &self, point: u32, ) -> Result<Vec<SchreierGenerator>, GroupError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: validation/unit/groups/test_acceptance_workload.py:60 · validation/unit/groups/test_acceptance_workload.py:61 · validation/unit/groups/test_acceptance_workload.py:62 · validation/unit/groups/test_acceptance_workload.py:63 · validation/unit/groups/test_acceptance_workload.py:64 · validation/unit/groups/test_acceptance_workload.py:65

`groups.PermutationGroup.schreier_tree`¶

The Schreier tree of point under the full group.

Detailed contract

The Schreier tree of point under the full group. Returns a [SchreierTree] (BFS orbit + predecessor table).

The Schreier tree of point under the full group. The result is a public, owned snapshot — parents[p] is Some((parent, generator-index)) for non-root orbit points.

PythonRust

(self, point: int) -> SchreierTree

noether::groups::PermutationGroup::schreier_tree · Direct Rust declaration

pub fn schreier_tree(&self, point: u32) -> Result<SchreierTree, GroupError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: validation/unit/groups/test_acceptance_workload.py:53 · validation/parity/_noether_bsgs.py:114 · validation/parity/m1_bsgs.py:331 · validation/parity/m1_bsgs.py:37

`groups.PermutationGroup.set_stabilizer`¶

The set stabilizer Stab_self(points) under the OnSets action — the subgroup fixing points setwise — as a PermGroup.

Detailed contract

The set stabilizer Stab_self(points) under the OnSets action — the subgroup fixing points setwise — as a PermGroup. Duplicate points are canonicalized (sort + dedup); a point >= degree raises ValueError.

The set stabilizer Stab_self(set) under the OnSets action — the subgroup of self fixing set setwise. Duplicate points in set are canonicalized (sort + dedup), not an error. §Errors GroupError::DegreeMismatch if any point in set is ≥ degree; GroupError::SearchBudgetExceeded on an exhausted budget. use perm_core::{PermGroup, Perm}; // Stab_{S_3}({0,1}) = ⟨(0 1)⟩, order 2. let s3 = PermGroup::from_generators( 3, &[Perm::from_images(&[1, 0, 2]).unwrap(), Perm::from_images(&[1, 2, 0]).unwrap()], ).unwrap(); assert_eq!(s3.set_stabilizer(&[0, 1]).unwrap().order(), perm_core::BigUInt::from(2u64));

PythonRust

(self, points: Sequence[int]) -> PermutationGroup

noether::groups::PermutationGroup::set_stabilizer · Direct Rust declaration

pub fn set_stabilizer(&self, set: &[u32]) -> Result<PermGroup, GroupError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: validation/unit/groups/test_acceptance_workload.py:118 · validation/unit/infra/test_magma_release_protocol.py:207 · validation/unit/infra/test_magma_release_protocol.py:208 · validation/unit/infra/test_magma_release_protocol.py:209 · validation/parity/groups/test_perm_core_gap_parity.py:100 · validation/parity/groups/test_perm_core_gap_parity.py:121

`groups.PermutationGroup.sift`¶

Sift g through the stabilizer chain.

Detailed contract

Sift g through the stabilizer chain. Returns the sift residue and a bool indicating membership (residue is the identity iff g ∈ G).

Sift g down the stabilizer chain. Returns the sift residue and, on true, the sift terminated with the identity (i.e. g ∈ G). On false, the residue is the first non-trivial element encountered — a “witness of non- membership”.

PythonRust

(self, element: Permutation) -> tuple[Permutation, bool]

noether::groups::PermutationGroup::sift · Direct Rust declaration

pub fn sift(&self, g: &Perm) -> Result<(Perm, bool), GroupError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	attached / bounded
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: validation/unit/groups/test_acceptance_workload.py:101

`groups.PermutationGroup.stabilizer`¶

The stabilizer of one point.

PythonRust

(self, point: int) -> PermutationGroup

noether::groups::PermutationGroup · Python projection

Python projection convenience over this Rust mathematical type

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: examples/19_permutation_groups.py:15 · examples/19_permutation_groups.py:18 · examples/19_permutation_groups.py:3 · examples/20_conjugacy_classes.py:3 · validation/unit/groups/test_acceptance_workload.py:41 · validation/unit/groups/test_acceptance_workload.py:45

`groups.PermutationGroup.stabilizer_chain`¶

The full stabilizer chain.

Detailed contract

The full stabilizer chain. Returns a [StabilizerChain] whose steps exposes per-level base point, generators, orbit, and transversal.

The base + per-level transversal — i.e. the full stabilizer chain G > G^(1) > G^(2) > ... > {1}, with each level’s base point, generating set, orbit (in BFS order), and transversal.

PythonRust

(self) -> StabilizerChain

noether::groups::PermutationGroup::stabilizer_chain · Direct Rust declaration

pub fn stabilizer_chain(&self) -> StabilizerChain

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: validation/unit/groups/test_acceptance_workload.py:67 · validation/parity/m1_bsgs.py:332 · validation/parity/m1_bsgs.py:40

`groups.PermutationGroup.strong_generating_set`¶

The strong generating set, returned as list[Permutation] in the order the generators were added (top of the chain first).

Detailed contract

The strong generating set, returned as list[Permutation] in the order the generators were added (top of the chain first).

The strong generating set: the union, across levels, of the generators at each level. Returned in the order they were added (G^(0) first).

PythonRust

(self) -> list[Permutation]

noether::groups::PermutationGroup::strong_generating_set · Direct Rust declaration

pub fn strong_generating_set(&self) -> Vec<&Perm>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	attached / bounded
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: validation/unit/groups/test_acceptance_workload.py:72

`groups.PermutationGroup.sylow_subgroup`¶

A deterministic Sylow p-subgroup in this concrete action.

Detailed contract

A deterministic Sylow p-subgroup in this concrete permutation group. The returned subgroup acts on the same domain and is literally contained in self. The exact native lane enumerates groups of order at most SUBGROUP_ENUMERATION_CAP and fails before partial work above that bound. Full symmetric groups use their standard iterated-wreath Sylow subgroup and do not enumerate the ambient group. §Errors GroupError::InvalidPrime when prime is not prime; GroupError::EnumerationLimitExceeded above the exact native cap; construction or membership errors from the permutation-group kernel.

PythonRust

(self, prime: int) -> PermutationGroup

noether::groups::PermutationGroup::sylow_subgroup · Direct Rust declaration

pub fn sylow_subgroup(&self, prime: u64) -> Result<PermGroup, GroupError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: validation/unit/groups/test_conjugacy.py:62 · validation/unit/groups/test_permutation_group_facade.py:86 · validation/unit/groups/test_permutation_group_facade.py:87 · validation/unit/groups/test_permutation_group_facade.py:89 · validation/bench/magma_release.py:1548

`groups.PermutationGroup.transversal`¶

A transversal of the point stabilizer of point in G.

Detailed contract

A transversal of the point stabilizer of point in G. Returns a [Transversal] whose reps[i] maps point to orbit[i].

A transversal for the coset action of the point stabilizer of point in G. Returns one representative per coset, keyed to its image — i.e. reps[i] maps point to orbit[i]. Fast-path: when point is the chain’s first base point, the level-0 Schreier tree + coset reps are already cached on self. Reuse them rather than rebuilding the BFS from scratch. (The cached level-0 generators are exactly self.generators, modulo trivial filtering, since deterministic Schreier–Sims seeds level 0 with the input generators — see the bootstrap in schreier_sims_deterministic.)

PythonRust

(self, point: int) -> Transversal

noether::groups::PermutationGroup::transversal · Direct Rust declaration

pub fn transversal(&self, point: u32) -> Result<Transversal, GroupError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	released
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: validation/unit/groups/test_acceptance_workload.py:47 · validation/unit/groups/test_acceptance_workload.py:48 · validation/unit/groups/test_acceptance_workload.py:49 · validation/unit/groups/test_acceptance_workload.py:50 · validation/unit/groups/test_acceptance_workload.py:51 · validation/unit/groups/test_acceptance_workload.py:71

`groups.PermutationGroup.uniform_random_element`¶

A uniform random element via per-level transversal sampling.

Detailed contract

A uniform random element via per-level transversal sampling. Exact uniform draw (not a walk). Returns a [RandomElement] carrying the element and the seed it was generated from.

Sample a uniformly random group element via per-level coset choice. Returns the element plus the seed it was generated from (so the result is reproducible).

PythonRust

(self, seed: int) -> RandomElement

noether::groups::PermutationGroup::uniform_random_element · Direct Rust declaration

pub fn uniform_random_element(&self, seed: u64) -> RandomElement

Contract	Value
Guarantee	checked deterministic result
Determinism	seeded
Availability	default CPU build
Domain implementation crates	noether, perm-core
GIL	attached / bounded
Semantic ID	noether/groups/PermutationGroup@1

Executable usage: examples/19_permutation_groups.py:16 · validation/unit/groups/test_acceptance_workload.py:86 · validation/unit/groups/test_acceptance_workload.py:87 · validation/unit/groups/test_permutation_group_facade.py:65 · validation/unit/groups/test_permutation_group_facade.py:66 · validation/parity/_noether_bsgs.py:106

groups · PermutationGroup¶

Worked example¶

groups.PermutationGroup¶

groups.PermutationGroup.__contains__¶

groups.PermutationGroup.abelian_invariant_factors¶

groups.PermutationGroup.abelianization_invariant_factors¶

groups.PermutationGroup.base¶

groups.PermutationGroup.base_and_strong_generating_set¶

groups.PermutationGroup.complete_abelian_integral_cohomology¶

groups.PermutationGroup.complete_abelian_modular_cohomology¶

groups.PermutationGroup.complete_cyclic_integral_cohomology¶

groups.PermutationGroup.conjugacy_classes¶

groups.PermutationGroup.conjugating_element¶

groups.PermutationGroup.contains¶

groups.PermutationGroup.degree¶

groups.PermutationGroup.double_coset_triangle¶

groups.PermutationGroup.double_cosets¶

groups.PermutationGroup.embeds_up_to_conjugacy¶

groups.PermutationGroup.from_generators¶

groups.PermutationGroup.from_generators_randomized¶

groups.PermutationGroup.generators¶

groups.PermutationGroup.group_order¶

groups.PermutationGroup.identity¶

groups.PermutationGroup.integral_cohomology¶

groups.PermutationGroup.intersection¶

groups.PermutationGroup.inverse¶

groups.PermutationGroup.is_nilpotent¶

groups.PermutationGroup.is_perfect¶

groups.PermutationGroup.is_solvable¶

groups.PermutationGroup.is_transitive¶

groups.PermutationGroup.iterate_elements¶

groups.PermutationGroup.modular_cohomology¶

groups.PermutationGroup.multiply¶

groups.PermutationGroup.normalizer¶

groups.PermutationGroup.normalizer_in_symmetric¶

groups.PermutationGroup.orbit¶

groups.PermutationGroup.orbit_of_subset¶

groups.PermutationGroup.orbit_stabilizer¶

groups.PermutationGroup.orbits_on_pairs¶

groups.PermutationGroup.orbits_on_subsets¶

groups.PermutationGroup.order¶

groups.PermutationGroup.pair_orbits¶

groups.PermutationGroup.pointwise_stabilizer¶

groups.PermutationGroup.schreier_generators¶

groups.PermutationGroup.schreier_tree¶

groups.PermutationGroup.set_stabilizer¶

groups.PermutationGroup.sift¶

groups.PermutationGroup.stabilizer¶

groups.PermutationGroup.stabilizer_chain¶

groups.PermutationGroup.strong_generating_set¶

groups.PermutationGroup.sylow_subgroup¶

groups.PermutationGroup.transversal¶

groups.PermutationGroup.uniform_random_element¶

`groups.PermutationGroup`¶

`groups.PermutationGroup.contains`¶

`groups.PermutationGroup.abelian_invariant_factors`¶

`groups.PermutationGroup.abelianization_invariant_factors`¶

`groups.PermutationGroup.base`¶

`groups.PermutationGroup.base_and_strong_generating_set`¶

`groups.PermutationGroup.complete_abelian_integral_cohomology`¶

`groups.PermutationGroup.complete_abelian_modular_cohomology`¶

`groups.PermutationGroup.complete_cyclic_integral_cohomology`¶

`groups.PermutationGroup.conjugacy_classes`¶

`groups.PermutationGroup.conjugating_element`¶

`groups.PermutationGroup.contains`¶

`groups.PermutationGroup.degree`¶

`groups.PermutationGroup.double_coset_triangle`¶

`groups.PermutationGroup.double_cosets`¶

`groups.PermutationGroup.embeds_up_to_conjugacy`¶

`groups.PermutationGroup.from_generators`¶

`groups.PermutationGroup.from_generators_randomized`¶

`groups.PermutationGroup.generators`¶

`groups.PermutationGroup.group_order`¶

`groups.PermutationGroup.identity`¶

`groups.PermutationGroup.integral_cohomology`¶

`groups.PermutationGroup.intersection`¶

`groups.PermutationGroup.inverse`¶

`groups.PermutationGroup.is_nilpotent`¶

`groups.PermutationGroup.is_perfect`¶

`groups.PermutationGroup.is_solvable`¶

`groups.PermutationGroup.is_transitive`¶

`groups.PermutationGroup.iterate_elements`¶

`groups.PermutationGroup.modular_cohomology`¶

`groups.PermutationGroup.multiply`¶

`groups.PermutationGroup.normalizer`¶

`groups.PermutationGroup.normalizer_in_symmetric`¶

`groups.PermutationGroup.orbit`¶

`groups.PermutationGroup.orbit_of_subset`¶

`groups.PermutationGroup.orbit_stabilizer`¶

`groups.PermutationGroup.orbits_on_pairs`¶

`groups.PermutationGroup.orbits_on_subsets`¶

`groups.PermutationGroup.order`¶

`groups.PermutationGroup.pair_orbits`¶

`groups.PermutationGroup.pointwise_stabilizer`¶

`groups.PermutationGroup.schreier_generators`¶

`groups.PermutationGroup.schreier_tree`¶

`groups.PermutationGroup.set_stabilizer`¶

`groups.PermutationGroup.sift`¶

`groups.PermutationGroup.stabilizer`¶

`groups.PermutationGroup.stabilizer_chain`¶

`groups.PermutationGroup.strong_generating_set`¶

`groups.PermutationGroup.sylow_subgroup`¶

`groups.PermutationGroup.transversal`¶

`groups.PermutationGroup.uniform_random_element`¶