odeanalysis 0.1.0__py3-none-any.whl

odeanalysis/__init__.py

@@ -0,0 +1,296 @@
+"""Primary public API for symbolic structural ODE analysis.
+
+Expert APIs remain available from their defining submodules; see
+``docs/api-classification.md`` for the stability policy.
+"""
+
+__version__ = "0.25.2"
+
+from ._moser import moser_reduce
+from .analytic_continuation import (
+    CanonicalBasis,
+    ConnectionMatrix,
+    LocalMonodromy,
+    StokesMatrix,
+    connection_matrix,
+    hypergeometric_connection_matrix,
+    kummer_connection_matrices,
+    local_monodromy,
+    stokes_matrices,
+)
+from .block_decomposition import (
+    LeveltTurrittinReduction,
+    formal_block_diagonalize,
+    levelt_turrittin_reduce,
+)
+from .canonical import (
+    CanonicalEquationFamily,
+    CanonicalEquationRecognition,
+    recognize_canonical_equation,
+    transform_to_canonical,
+)
+from .certified_continuation import (
+    CertifiedContinuationResult,
+    CertifiedMatrixEnclosure,
+    certified_system_continuation,
+)
+from .dominance import (
+    SolutionDominanceAnalysis,
+    classify_solution_dominance,
+)
+from .factorization import (
+    FirstOrderFactorization,
+    factor_differential_operator,
+    is_reducible_operator,
+)
+from .formal import complete_formal_exponential_parts, formal_asymptotic_solutions
+from .formal_basis import formal_monodromy, logarithmic_frobenius_basis
+from .frobenius import FrobeniusAnalysis, frobenius_analysis
+from .fuchsian import (
+    ApparentSingularityAnalysis,
+    FuchsRelation,
+    RiemannScheme,
+    apparent_singularity_analysis,
+    fuchs_relation,
+    is_apparent_singularity,
+    riemann_scheme,
+)
+from .interchange import FormalODEData, formal_ode_data
+from .interoperability import (
+    CyclicScalarization,
+    ScalarSystemCorrespondence,
+    scalar_system_correspondence,
+    scalarize_system,
+)
+from .irregular import formal_exponential_parts, wkb_ansatze
+from .kovacic import KovacicAnalysis, KovacicOutcome, kovacic_analysis
+from .levelt import LeveltStructure, levelt_structure
+from .local_analysis import (
+    LocalAnalysisStratum,
+    ParameterizedLocalAnalysis,
+    ResonanceStratum,
+    local_parameter_analysis,
+)
+from .local_structure import (
+    FrobeniusConvergence,
+    FrobeniusLocalMonodromy,
+    SingularityPointStructure,
+    SingularityStructure,
+    frobenius_convergence,
+    frobenius_local_monodromy,
+    singularity_structure,
+)
+from .matrix_series import MatrixLaurentSeries
+from .newton import (
+    DifferentialNewtonPolygon,
+    SlopeFiltration,
+    differential_newton_polygon,
+    katz_rank,
+    newton_slopes,
+    poincare_rank,
+    slope_filtration,
+)
+from .operator import LinearDifferentialOperator
+from .parameter_wkb import (
+    ParameterizedTurningAnalysis,
+    ParameterizedTurningStratum,
+    parameterized_turning_analysis,
+)
+from .singularities import (
+    ODESingularityAnalysis,
+    ODESingularityKind,
+    analyze_ode_singularities,
+    classify_ode_point,
+    ode_singular_points,
+)
+from .stokes import StokesGeometry, stokes_geometry
+from .system import FirstOrderSystem
+from .system_analysis import (
+    FormalReductionCertificate,
+    FormalSystemAnalysis,
+    ParameterizedSystemAnalysis,
+    ParameterizedSystemFormalTypes,
+    SystemFormalTypeSignature,
+    SystemFormalTypeStratum,
+    SystemParameterStratum,
+    SystemResonance,
+    SystemSingularityAnalysis,
+    SystemStokesGeometry,
+    SystemStokesPair,
+    analyze_system_singularity,
+    formal_system_analysis,
+    system_formal_type_stratification,
+    system_parameter_analysis,
+    system_stokes_geometry,
+)
+from .transition_loci import (
+    LeadingMatrixRankAnalysis,
+    ProjectivePolynomialStratum,
+    leading_rank_analysis,
+    newton_loci,
+    singularity_loci,
+    singularity_projective_strata,
+    stokes_formal_loci,
+    stokes_ray_loci,
+    turning_loci,
+    turning_point_projective_strata,
+)
+from .turning import (
+    LiouvilleNormalForm,
+    TurningPoint,
+    TurningPointAnalysis,
+    TurningPointKind,
+    UniformWKBReduction,
+    WKBExpansion,
+    airy_uniformization,
+    analyze_turning_points,
+    classify_turning_point,
+    liouville_normal_form,
+    turning_points,
+    weber_uniformization,
+    wkb_expansion,
+)
+from .wronskian import WronskianAnalysis, abel_wronskian, wronskian_analysis
+
+__all__ = (
+    "ApparentSingularityAnalysis",
+    "CanonicalBasis",
+    "CanonicalEquationFamily",
+    "CanonicalEquationRecognition",
+    "CertifiedContinuationResult",
+    "CertifiedMatrixEnclosure",
+    "ConnectionMatrix",
+    "CyclicScalarization",
+    "DifferentialNewtonPolygon",
+    "FirstOrderFactorization",
+    "FirstOrderSystem",
+    "FormalODEData",
+    "FormalReductionCertificate",
+    "FormalSystemAnalysis",
+    "FrobeniusAnalysis",
+    "FrobeniusConvergence",
+    "FrobeniusLocalMonodromy",
+    "FuchsRelation",
+    "KovacicAnalysis",
+    "KovacicOutcome",
+    "LeadingMatrixRankAnalysis",
+    "LeveltStructure",
+    "LeveltTurrittinReduction",
+    "LinearDifferentialOperator",
+    "LiouvilleNormalForm",
+    "LocalAnalysisStratum",
+    "LocalMonodromy",
+    "MatrixLaurentSeries",
+    "ODESingularityAnalysis",
+    "ODESingularityKind",
+    "ParameterizedLocalAnalysis",
+    "ParameterizedSystemAnalysis",
+    "ParameterizedSystemFormalTypes",
+    "ParameterizedTurningAnalysis",
+    "ParameterizedTurningStratum",
+    "ProjectivePolynomialStratum",
+    "ResonanceStratum",
+    "RiemannScheme",
+    "ScalarSystemCorrespondence",
+    "SingularityPointStructure",
+    "SingularityStructure",
+    "SlopeFiltration",
+    "SolutionDominanceAnalysis",
+    "StokesGeometry",
+    "StokesMatrix",
+    "SystemFormalTypeSignature",
+    "SystemFormalTypeStratum",
+    "SystemParameterStratum",
+    "SystemResonance",
+    "SystemSingularityAnalysis",
+    "SystemStokesGeometry",
+    "SystemStokesPair",
+    "TurningPoint",
+    "TurningPointAnalysis",
+    "TurningPointKind",
+    "UniformWKBReduction",
+    "WKBExpansion",
+    "WronskianAnalysis",
+    "__version__",
+    "abel_wronskian",
+    "airy_uniformization",
+    "analyze_ode_singularities",
+    "analyze_system_singularity",
+    "analyze_turning_points",
+    "apparent_singularity_analysis",
+    "certified_system_continuation",
+    "classify_ode_point",
+    "classify_solution_dominance",
+    "classify_turning_point",
+    "complete_formal_exponential_parts",
+    "connection_matrix",
+    "differential_newton_polygon",
+    "factor_differential_operator",
+    "formal_asymptotic_solutions",
+    "formal_block_diagonalize",
+    "formal_exponential_parts",
+    "formal_monodromy",
+    "formal_ode_data",
+    "formal_system_analysis",
+    "frobenius_analysis",
+    "frobenius_convergence",
+    "frobenius_local_monodromy",
+    "fuchs_relation",
+    "hypergeometric_connection_matrix",
+    "is_apparent_singularity",
+    "is_reducible_operator",
+    "katz_rank",
+    "kovacic_analysis",
+    "kummer_connection_matrices",
+    "leading_rank_analysis",
+    "levelt_structure",
+    "levelt_turrittin_reduce",
+    "liouville_normal_form",
+    "local_monodromy",
+    "local_parameter_analysis",
+    "logarithmic_frobenius_basis",
+    "moser_reduce",
+    "newton_loci",
+    "newton_slopes",
+    "ode_singular_points",
+    "parameterized_turning_analysis",
+    "poincare_rank",
+    "recognize_canonical_equation",
+    "riemann_scheme",
+    "scalar_system_correspondence",
+    "scalarize_system",
+    "singularity_loci",
+    "singularity_projective_strata",
+    "singularity_structure",
+    "slope_filtration",
+    "stokes_formal_loci",
+    "stokes_geometry",
+    "stokes_matrices",
+    "stokes_ray_loci",
+    "system_formal_type_stratification",
+    "system_parameter_analysis",
+    "system_stokes_geometry",
+    "transform_to_canonical",
+    "turning_loci",
+    "turning_point_projective_strata",
+    "turning_points",
+    "weber_uniformization",
+    "wkb_ansatze",
+    "wkb_expansion",
+    "wronskian_analysis",
+)
+
+
+def __dir__() -> list[str]:
+    """Return the documented root API and standard module metadata."""
+
+    metadata = {
+        "__doc__",
+        "__file__",
+        "__loader__",
+        "__name__",
+        "__package__",
+        "__path__",
+        "__spec__",
+    }
+    return sorted(metadata | set(__all__))

odeanalysis/_api_policy.py

@@ -0,0 +1,179 @@
+"""Classification of the supported public API surface.
+
+Primary names are available directly from :mod:`odeanalysis`. Expert names
+remain public from their defining submodules. Private modules and helpers are
+implementation details and carry no compatibility contract.
+"""
+
+from __future__ import annotations
+
+PRIMARY_EXPORTS: dict[str, str] = {
+    "FormalSystemAnalysis": ".system_analysis",
+    "ParameterizedSystemAnalysis": ".system_analysis",
+    "SystemParameterStratum": ".system_analysis",
+    "SystemResonance": ".system_analysis",
+    "SystemSingularityAnalysis": ".system_analysis",
+    "SystemStokesGeometry": ".system_analysis",
+    "SystemStokesPair": ".system_analysis",
+    "analyze_system_singularity": ".system_analysis",
+    "formal_system_analysis": ".system_analysis",
+    "system_parameter_analysis": ".system_analysis",
+    "system_stokes_geometry": ".system_analysis",
+    "FrobeniusConvergence": ".local_structure",
+    "FrobeniusLocalMonodromy": ".local_structure",
+    "ResonanceStratum": ".local_analysis",
+    "SingularityPointStructure": ".local_structure",
+    "SingularityStructure": ".local_structure",
+    "WronskianAnalysis": ".wronskian",
+    "abel_wronskian": ".wronskian",
+    "frobenius_convergence": ".local_structure",
+    "frobenius_local_monodromy": ".local_structure",
+    "singularity_structure": ".local_structure",
+    "wronskian_analysis": ".wronskian",
+    "CanonicalBasis": ".analytic_continuation",
+    "ConnectionMatrix": ".analytic_continuation",
+    "LocalAnalysisStratum": ".local_analysis",
+    "LocalMonodromy": ".analytic_continuation",
+    "StokesMatrix": ".analytic_continuation",
+    "connection_matrix": ".analytic_continuation",
+    "hypergeometric_connection_matrix": ".analytic_continuation",
+    "kummer_connection_matrices": ".analytic_continuation",
+    "local_monodromy": ".analytic_continuation",
+    "stokes_matrices": ".analytic_continuation",
+    "LiouvilleNormalForm": ".turning",
+    "TurningPoint": ".turning",
+    "TurningPointAnalysis": ".turning",
+    "TurningPointKind": ".turning",
+    "UniformWKBReduction": ".turning",
+    "WKBExpansion": ".turning",
+    "airy_uniformization": ".turning",
+    "analyze_turning_points": ".turning",
+    "classify_turning_point": ".turning",
+    "liouville_normal_form": ".turning",
+    "turning_points": ".turning",
+    "weber_uniformization": ".turning",
+    "wkb_expansion": ".turning",
+    "CanonicalEquationFamily": ".canonical",
+    "CanonicalEquationRecognition": ".canonical",
+    "FirstOrderFactorization": ".factorization",
+    "KovacicAnalysis": ".kovacic",
+    "KovacicOutcome": ".kovacic",
+    "factor_differential_operator": ".factorization",
+    "is_reducible_operator": ".factorization",
+    "kovacic_analysis": ".kovacic",
+    "recognize_canonical_equation": ".canonical",
+    "transform_to_canonical": ".canonical",
+    "DifferentialNewtonPolygon": ".newton",
+    "differential_newton_polygon": ".newton",
+    "ApparentSingularityAnalysis": ".fuchsian",
+    "FormalODEData": ".interchange",
+    "FrobeniusAnalysis": ".frobenius",
+    "FirstOrderSystem": ".system",
+    "FuchsRelation": ".fuchsian",
+    "LeveltStructure": ".levelt",
+    "LeveltTurrittinReduction": ".block_decomposition",
+    "LinearDifferentialOperator": ".operator",
+    "MatrixLaurentSeries": ".matrix_series",
+    "ODESingularityAnalysis": ".singularities",
+    "ODESingularityKind": ".singularities",
+    "ParameterizedLocalAnalysis": ".local_analysis",
+    "RiemannScheme": ".fuchsian",
+    "SlopeFiltration": ".newton",
+    "SolutionDominanceAnalysis": ".dominance",
+    "StokesGeometry": ".stokes",
+    "analyze_ode_singularities": ".singularities",
+    "apparent_singularity_analysis": ".fuchsian",
+    "classify_ode_point": ".singularities",
+    "classify_solution_dominance": ".dominance",
+    "complete_formal_exponential_parts": ".formal",
+    "formal_asymptotic_solutions": ".formal",
+    "formal_block_diagonalize": ".block_decomposition",
+    "formal_exponential_parts": ".irregular",
+    "formal_monodromy": ".formal_basis",
+    "formal_ode_data": ".interchange",
+    "frobenius_analysis": ".frobenius",
+    "fuchs_relation": ".fuchsian",
+    "is_apparent_singularity": ".fuchsian",
+    "katz_rank": ".newton",
+    "levelt_structure": ".levelt",
+    "levelt_turrittin_reduce": ".block_decomposition",
+    "logarithmic_frobenius_basis": ".formal_basis",
+    "moser_reduce": "._moser",
+    "newton_slopes": ".newton",
+    "ode_singular_points": ".singularities",
+    "local_parameter_analysis": ".local_analysis",
+    "LeadingMatrixRankAnalysis": ".transition_loci",
+    "ProjectivePolynomialStratum": ".transition_loci",
+    "leading_rank_analysis": ".transition_loci",
+    "newton_loci": ".transition_loci",
+    "singularity_loci": ".transition_loci",
+    "singularity_projective_strata": ".transition_loci",
+    "stokes_formal_loci": ".transition_loci",
+    "stokes_ray_loci": ".transition_loci",
+    "turning_point_projective_strata": ".transition_loci",
+    "turning_loci": ".transition_loci",
+    "poincare_rank": ".newton",
+    "riemann_scheme": ".fuchsian",
+    "slope_filtration": ".newton",
+    "stokes_geometry": ".stokes",
+    "wkb_ansatze": ".irregular",
+    "CertifiedContinuationResult": ".certified_continuation",
+    "CertifiedMatrixEnclosure": ".certified_continuation",
+    "certified_system_continuation": ".certified_continuation",
+    "CyclicScalarization": ".interoperability",
+    "ScalarSystemCorrespondence": ".interoperability",
+    "scalarize_system": ".interoperability",
+    "scalar_system_correspondence": ".interoperability",
+    "FormalReductionCertificate": ".system_analysis",
+    "ParameterizedSystemFormalTypes": ".system_analysis",
+    "SystemFormalTypeSignature": ".system_analysis",
+    "SystemFormalTypeStratum": ".system_analysis",
+    "system_formal_type_stratification": ".system_analysis",
+    "ParameterizedTurningAnalysis": ".parameter_wkb",
+    "ParameterizedTurningStratum": ".parameter_wkb",
+    "parameterized_turning_analysis": ".parameter_wkb",
+}
+
+EXPERT_EXPORTS: dict[str, str] = {
+    "KovacicCase2Certificate": ".kovacic",
+    "KovacicCase3Certificate": ".kovacic",
+    "CompleteFormalExponentialPart": ".formal",
+    "DifferentialNewtonEdge": ".newton",
+    "DifferentialNewtonPoint": ".newton",
+    "ExponentialBlockDecomposition": ".block_decomposition",
+    "FormalAmplitudeSeries": ".formal",
+    "FormalAsymptoticSolution": ".formal",
+    "FormalBlockDiagonalization": ".block_decomposition",
+    "FormalBlockPartition": ".system",
+    "FormalExponentialPart": ".irregular",
+    "FormalLogarithmicBasis": ".formal_basis",
+    "FormalMonodromy": ".formal_basis",
+    "IrregularSingularityInvariants": ".irregular",
+    "RamificationStep": ".block_decomposition",
+    "RegularSingularLeveltReduction": ".levelt",
+    "SparseLaurentSeries": ".series",
+    "StokesConnectionPattern": ".stokes",
+    "StokesPairGeometry": ".stokes",
+    "StokesRay": ".stokes",
+    "StokesSector": ".stokes",
+    "WKBAnsatz": ".irregular",
+    "companion_system": ".system",
+    "complete_exponential_bell_polynomial": ".bell",
+    "complete_exponential_bell_via_sympy": ".bell",
+    "differential_bell_laurent_series": ".formal",
+    "differential_bell_polynomials": ".formal",
+    "exponential_block_decomposition": ".block_decomposition",
+    "formal_amplitude_series": ".formal",
+    "formal_block_partition": ".system",
+    "formal_logarithmic_basis": ".formal_basis",
+    "green_operator_data": ".interchange",
+    "irregular_singularity_invariants": ".irregular",
+    "levelt_reduce_regular_singular": ".levelt",
+    "local_order_and_leading_coefficient": ".newton",
+    "localize_operator": ".newton",
+    "ramified_pullback": ".block_decomposition",
+    "reduce_to_fuchsian": ".levelt",
+    "riccati_expression": ".formal",
+    "stokes_connection_patterns": ".stokes",
+    "stokes_geometry_from_exponential_parts": ".stokes",
+}

odeanalysis/_assumptions.py

@@ -0,0 +1,89 @@
+"""Shared assumptions and proof-oriented zero decisions."""
+
+from __future__ import annotations
+
+import sympy as sp
+from funcprops import entails, normalize_assumptions
+
+try:
+    from exprtest import zerotest as _exprtest_zerotest
+except ImportError:  # Optional stronger oracle; funcprops remains sufficient.
+    _exprtest_zerotest = None
+
+
+def zero_status(expr: sp.Expr, assumptions: sp.Expr | bool = True) -> bool | None:
+    """Prove zero/nonzero when cheap, returning ``None`` when unresolved.
+
+    Fast structural and SymPy assumption checks run first.  ``funcprops`` handles
+    bounded logical entailment.  If installed, ``exprtest`` is used last and
+    only with ``confidence='certified'`` so heuristic nonzero evidence can never
+    steer an ODE classification branch.
+    """
+    assumptions = normalize_assumptions(assumptions)
+    value = sp.sympify(expr)
+    if value == 0 or value.is_zero is True:
+        return True
+    if value.is_zero is False:
+        return False
+    simplified = sp.cancel(sp.together(value)) if sp.count_ops(value) <= 24 else value
+    if simplified == 0 or simplified.is_zero is True:
+        return True
+    if simplified.is_zero is False:
+        return False
+    if sp.count_ops(simplified) <= 24:
+        try:
+            decision = entails(sp.Eq(simplified, 0, evaluate=False), assumptions)
+        except (RecursionError, TypeError, ValueError):
+            decision = None
+        if decision is not None:
+            return decision
+    use_exprtest = _exprtest_zerotest is not None and not simplified.has(
+        sp.nan, sp.zoo, sp.oo, -sp.oo
+    )
+    if simplified.free_symbols and simplified.is_rational_function(
+        *simplified.free_symbols
+    ):
+        use_exprtest = False
+    if use_exprtest:
+        try:
+            return _exprtest_zerotest(
+                simplified, assumptions=assumptions, confidence="certified"
+            )
+        except (RecursionError, TypeError, ValueError):
+            return None
+    return None
+
+
+def nonzero_status(expr: sp.Expr, assumptions: sp.Expr | bool = True) -> bool | None:
+    z = zero_status(expr, assumptions)
+    return None if z is None else not z
+
+
+def assumption_substitutions(
+    assumptions: sp.Expr | bool = True,
+) -> dict[sp.Symbol, sp.Expr]:
+    """Extract direct symbol equalities from a conjunction of assumptions."""
+    assumptions = normalize_assumptions(assumptions)
+    result: dict[sp.Symbol, sp.Expr] = {}
+    for clause in sp.And.make_args(assumptions):
+        if not isinstance(clause, sp.Equality):
+            continue
+        lhs, rhs = clause.lhs, clause.rhs
+        if isinstance(lhs, sp.Symbol) and lhs not in rhs.free_symbols:
+            result[lhs] = rhs
+        elif isinstance(rhs, sp.Symbol) and rhs not in lhs.free_symbols:
+            result[rhs] = lhs
+            continue
+        expr = sp.expand(lhs - rhs)
+        for symbol in sorted(expr.free_symbols, key=sp.default_sort_key, reverse=True):
+            try:
+                poly = sp.Poly(expr, symbol)
+            except (sp.PolynomialError, TypeError, ValueError):
+                continue
+            if poly.degree() == 1:
+                aa, bb = poly.all_coeffs()
+                value = sp.cancel(-bb / aa)
+                if symbol not in value.free_symbols:
+                    result[symbol] = value
+                    break
+    return result

odeanalysis/_block_common.py

@@ -0,0 +1,106 @@
+"""Shared exact helpers for formal block reduction."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import sympy as sp
+
+from .matrix_series import MatrixLaurentSeries
+
+
+class BlockDecompositionError(NotImplementedError):
+    """Raised when an exact formal block split cannot be certified."""
+
+
+def is_zero_matrix(matrix: sp.MatrixBase) -> bool:
+    """Return whether every matrix entry simplifies exactly to zero."""
+
+    return all(sp.simplify(entry) == 0 for entry in matrix)
+
+
+def is_scalar_matrix(matrix: sp.MatrixBase) -> tuple[bool, sp.Expr]:
+    """Return whether ``matrix`` is scalar and, when so, its scalar value."""
+
+    matrix = sp.Matrix(matrix)
+    if matrix.rows != matrix.cols:
+        return False, sp.S.Zero
+    if matrix.rows == 0:
+        return True, sp.S.Zero
+    scalar = sp.simplify(matrix[0, 0])
+    for i in range(matrix.rows):
+        for j in range(matrix.cols):
+            expected = scalar if i == j else sp.S.Zero
+            if sp.simplify(matrix[i, j] - expected) != 0:
+                return False, sp.S.Zero
+    return True, scalar
+
+
+def matrix_block(
+    matrix: sp.MatrixBase,
+    row_start: int,
+    row_stop: int,
+    col_start: int,
+    col_stop: int,
+) -> sp.Matrix:
+    """Extract a dense matrix block."""
+
+    return sp.Matrix(matrix)[row_start:row_stop, col_start:col_stop]
+
+
+def series_block(
+    series: MatrixLaurentSeries,
+    row_start: int,
+    row_stop: int,
+    col_start: int,
+    col_stop: int,
+) -> MatrixLaurentSeries:
+    """Extract a block from every coefficient of a Laurent matrix series."""
+
+    rows = row_stop - row_start
+    cols = col_stop - col_start
+    coefficients: dict[int, sp.Matrix] = {}
+    for power, coefficient in series.terms:
+        block = matrix_block(coefficient, row_start, row_stop, col_start, col_stop)
+        if not is_zero_matrix(block):
+            coefficients[power] = block
+    return MatrixLaurentSeries.from_mapping(
+        series.variable,
+        coefficients,
+        shape=(rows, cols),
+    )
+
+
+def block_diag_series(
+    variable: sp.Symbol,
+    series_list: Sequence[MatrixLaurentSeries],
+) -> MatrixLaurentSeries:
+    """Assemble Laurent matrix series as a block diagonal series."""
+
+    if not series_list:
+        return MatrixLaurentSeries.zero(variable, 0, 0)
+    if any(series.variable != variable for series in series_list):
+        raise ValueError("all block series must use the same variable")
+    total_rows = sum(series.rows for series in series_list)
+    total_cols = sum(series.cols for series in series_list)
+    powers = sorted({power for series in series_list for power, _ in series.terms})
+    coefficients: dict[int, sp.Matrix] = {}
+    for power in powers:
+        blocks = [sp.Matrix(series.coefficient(power)) for series in series_list]
+        coefficient = sp.diag(*blocks)
+        if not is_zero_matrix(coefficient):
+            coefficients[power] = coefficient
+    return MatrixLaurentSeries.from_mapping(
+        variable,
+        coefficients,
+        shape=(total_rows, total_cols),
+    )
+
+
+def partition_offsets(dimensions: Sequence[int]) -> tuple[int, ...]:
+    """Return cumulative block offsets for ``dimensions``."""
+
+    offsets = [0]
+    for dimension in dimensions:
+        offsets.append(offsets[-1] + dimension)
+    return tuple(offsets)