Space groups¶
Family and normal space-subgroup enumeration, parent-normalizer actions, and translation sublattices.
dataclass
¶
FamilySpaceSubgroup(hermann_subgroup: SubgroupIndices, hermann_conjugates: tuple[SubgroupIndices, ...], hermann_normalizer: tuple[GroupElementIndex, ...], depth: int, operation_indices: tuple[int, ...], translation_sublattice: Sublattice, parent_rotations: NDArrayInt, parent_translations: NDArrayFloat, rotations: NDArrayInt, translations: NDArrayFloat, relative_sublattice: Sublattice | None, normalizer_action: ParentNormalizerAction, relative_k_index: int | None = None)
A family space subgroup and its Hermann translationengleiche supergroup.
The affine operations of the family subgroup are given both in the parent
basis (parent_rotations and parent_translations) and in the family
translation-lattice basis (rotations and translations).
operation_indices map those operations to the input parent-operation
order.
hermann_subgroup is the intermediate translationengleiche group
M in a Hermann chain G' <= M <= G. Its conjugacy class is under the
parent space group G. hermann_normalizer contains representatives
of N_G(M) / M in the parent-operation order. Exact-lattice
klassengleiche subgroups of a fixed M are classified by moyopy under
conjugation by M. normalizer_action contains representatives of the
full parent-space-group quotient N_G(G′) / G′, including distinct parent-lattice
translations modulo the translation lattice of G′.
depth is the shortest covering-chain length from G to M in the
translationengleiche subgroup lattice. The parent has depth zero and its
maximal proper translationengleiche subgroups have depth one. For a
bounded family subgroup, depth describes M, not the full subgroup.
is_subgroup_of(other: FamilySpaceSubgroup, *, atol: float) -> bool
Return whether this affine family group is contained in other.
FamilySpaceSubgroupEnumerator(parent_rotations: NDArrayInt, parent_translations: NDArrayFloat, *, epsilon: float, target_sublattice: Sublattice | None, atol: float)
Enumerate family space subgroups through Hermann decomposition.
For a parent space group G, each result is obtained from a chain
G' <= M <= G in which M is translationengleiche in G and
G' is klassengleiche in M.
With up_to_parent_conjugacy=True, translationengleiche groups M are
identified under conjugation by G, restricted to the stabilizer
{g in G | gL = L} when a target translation lattice L is fixed. For a
fixed M, candidate family lattices are identified under the rotation
action of N_G(M) / M; with a target L, this action is likewise restricted
to {g in N_G(M) | gL = L}. For a fixed M and family lattice, moyopy
identifies exact-lattice klassengleiche subgroups under conjugation by M.
Every result carries the action of its normalizer in the parent space group,
N_G(G′) / G′. With up_to_parent_conjugacy=False, every translationengleiche
and klassengleiche conjugate is emitted and the family-lattice normalizer
reduction is skipped.
This class handles only space-group operations and lattices. Magnetic-site multiplicity and spin-space-group construction belong to the configuration layer.
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
parent_rotations
|
NDArrayInt
|
Operations of the parent space group |
required |
parent_translations
|
NDArrayInt
|
Operations of the parent space group |
required |
epsilon
|
float
|
Tolerance passed to moyopy's translationengleiche enumeration. |
required |
target_sublattice
|
Sublattice | None
|
Optional propagation-vector-derived lattice that every enumerated family translation lattice must contain. |
required |
atol
|
float
|
Tolerance for integral lattice and affine-operation comparisons. |
required |
property
¶
representative_subgroups: frozenset[SubgroupIndices]
Representatives of t-subgroups under parent-space-group conjugacy.
property
¶
translationengleiche_subgroups: tuple[FamilySpaceSubgroup, ...]
enumerate(*, k_index: int = 1, up_to_parent_conjugacy: bool = True, max_depth: int | None = None) -> list[FamilySpaceSubgroup]
Enumerate subgroups satisfying the requested bounds.
max_depth bounds the Hermann translationengleiche depth, not the
depth of the full family subgroup. In particular, max_depth=1
retains the parent and maximal proper Hermann subgroups, together with
bounded descendants of those Hermann groups. This does not test affine
maximality among the emitted family subgroups.
Translationengleiche subgroups are returned first, ordered by decreasing Hermann-group order. Bounded subgroups follow, ordered by increasing family-lattice index and then decreasing Hermann-group order.
enumerate_normal(*, k_index: int = 1, up_to_parent_conjugacy: bool = True, max_depth: int | None = None) -> list[FamilySpaceSubgroup]
Enumerate bounded family subgroups normal in the full parent group.
A candidate G′ is normal precisely when its stored parent
normalizer quotient exhausts the parent quotient, that is,
|N_G(G′) / G′| = [G : G′]. This tests normality in the original
parent G, including for general subgroups whose Hermann group is a
proper subgroup of G.
k_index and max_depth have the same finite-bound semantics as
:meth:enumerate.
dataclass
¶
NormalSpaceSubgroup(point_subgroup: list[GroupElementIndex], translations: NDArrayFloat, sublattice: Sublattice, coset_representatives: list[GroupElementIndex], quotient_table: NDArrayInt)
NormalSpaceSubgroupEnumerator(prim_rotations: NDArrayInt, prim_translations: NDArrayFloat, table: NDArrayInt, *, sublattice: Sublattice | None = None, atol: float = 1e-06)
enumerate(normal_point_subgroup: list[GroupElementIndex], *, k_index: int | None = None) -> list[NormalSpaceSubgroup]
Enumerate normal space subgroups with the requested point subgroup.
Moyopy supplies the embedded translationengleiche and klassengleiche subgroups. SpinForge filters those candidates to subgroups normal in the original parent and converts them to its legacy quotient metadata.
When sublattice is not specified, every invariant translation
sublattice with determinant k_index is considered.
dataclass
¶
ParentNormalizerAction(rotations: NDArrayInt, translations: NDArrayFloat, permutations: tuple[tuple[int, ...], ...])
Representatives and induced action of N_G(G′) / G′.
The conjugating operations belong to the parent space group G.
rotations and translations are expressed in the parent primitive
basis. permutations[a][i] is the index of the family operation
obtained from operation i by inverse conjugation with representative
a.
contains(sublattice: Sublattice, *, atol: float = 1e-05) -> bool
Return whether this lattice contains sublattice.
relative_sublattice(sublattice: Sublattice, *, atol: float = 1e-05) -> Sublattice | None
Express a contained sublattice in this lattice's basis.
Return None when sublattice is not contained in this lattice.
transform_operations(rotations: NDArrayInt, translations: NDArrayFloat, atol: float = 1e-05) -> tuple[NDArrayInt, NDArrayFloat]
Change operations into the sublattice basis P (ITA convention).
W' = P^-1 @ W @ P, w' = P^-1 @ w. Raises if a transformed rotation is not integral in the sublattice basis.
transform_operations_to_parent(rotations: NDArrayInt, translations: NDArrayFloat, atol: float = 1e-05) -> tuple[NDArrayInt, NDArrayFloat]
Change operations from the sublattice basis P to the parent basis.
W = P @ W' @ P^-1 and w = P @ w'. Raises if a transformed
rotation is not integral in the parent basis.
Enumerate normal point groups up to conjugacy classes.
enumerate_sublattices(index: int) -> list[Sublattice]
Enumerate index-index sublattices in Hermite normal form.