Skip to content

Machine-readable contracts

Download every accepted Python call schema · download canonical transport schemas.

The call index covers every accepted declaration and overload. The 34 entries below are the narrower, versioned cross-process transport registry. Generic hydration is deliberately limited to these Rust-owned schemas; deserialization revalidates every mathematical value.

noether/category/SteinerCategory@1

Python category.SteinerCategory · Rust domain

Validated finite strong Steiner category.

Canonical JSON Schema
{
  "$defs": {
    "SignedBoundaryWire": {
      "properties": {
        "negative": {
          "items": {
            "format": "uint",
            "minimum": 0,
            "type": "integer"
          },
          "type": "array"
        },
        "positive": {
          "items": {
            "format": "uint",
            "minimum": 0,
            "type": "integer"
          },
          "type": "array"
        }
      },
      "required": [
        "negative",
        "positive"
      ],
      "type": "object"
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "atom_counts": {
      "items": {
        "format": "uint",
        "minimum": 0,
        "type": "integer"
      },
      "type": "array"
    },
    "boundaries": {
      "items": {
        "items": {
          "$ref": "#/$defs/SignedBoundaryWire"
        },
        "type": "array"
      },
      "type": "array"
    },
    "type": {
      "type": "string"
    }
  },
  "required": [
    "type",
    "atom_counts",
    "boundaries"
  ],
  "title": "SteinerCategory",
  "type": "object"
}

noether/combin/Composition@1

Python combin.Composition · Rust domain

A thin Python handle around Noether's canonical integer composition.

Canonical JSON Schema
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "parts": {
      "items": {
        "format": "uint",
        "minimum": 0,
        "type": "integer"
      },
      "type": "array"
    }
  },
  "required": [
    "parts"
  ],
  "title": "Composition",
  "type": "object"
}

noether/combin/Graph@1

Python combin.Graph · Rust domain

The thin Python projection of Noether's CSR graph value.

Canonical JSON Schema
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "directed": {
      "type": "boolean"
    },
    "edges": {
      "items": {
        "maxItems": 3,
        "minItems": 3,
        "prefixItems": [
          {
            "format": "uint32",
            "minimum": 0,
            "type": "integer"
          },
          {
            "format": "uint32",
            "minimum": 0,
            "type": "integer"
          },
          {
            "format": "int64",
            "type": "integer"
          }
        ],
        "type": "array"
      },
      "type": "array"
    },
    "order": {
      "format": "uint",
      "minimum": 0,
      "type": "integer"
    }
  },
  "required": [
    "order",
    "edges",
    "directed"
  ],
  "title": "Graph",
  "type": "object"
}

noether/combin/KashiwaraCrystal@1

Python combin.KashiwaraCrystal · Rust domain

A thin Python handle around Noether's validated finite type-A crystal.

Canonical JSON Schema
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "cartan_matrix": {
      "items": {
        "items": {
          "format": "int64",
          "type": "integer"
        },
        "type": "array"
      },
      "type": "array"
    },
    "f_edges": {
      "items": {
        "items": {
          "format": "uint32",
          "minimum": 0,
          "type": [
            "integer",
            "null"
          ]
        },
        "type": "array"
      },
      "type": "array"
    },
    "weights": {
      "items": {
        "items": {
          "format": "int64",
          "type": "integer"
        },
        "type": "array"
      },
      "type": "array"
    }
  },
  "required": [
    "cartan_matrix",
    "weights",
    "f_edges"
  ],
  "title": "KashiwaraCrystal",
  "type": "object"
}

noether/combin/Matroid@1

Python combin.Matroid · Rust domain

A thin Python handle around Noether's validated Rust [Matroid].

Canonical JSON Schema
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "bases": {
      "items": {
        "items": {
          "format": "uint32",
          "minimum": 0,
          "type": "integer"
        },
        "type": "array"
      },
      "type": "array"
    },
    "ground_set": {
      "items": {
        "format": "uint32",
        "minimum": 0,
        "type": "integer"
      },
      "type": "array"
    }
  },
  "required": [
    "ground_set",
    "bases"
  ],
  "title": "Matroid",
  "type": "object"
}

noether/combin/Partition@1

Python combin.Partition · Rust domain

A thin Python handle around Noether's canonical integer partition.

Canonical JSON Schema
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "parts": {
      "items": {
        "format": "uint",
        "minimum": 0,
        "type": "integer"
      },
      "type": "array"
    }
  },
  "required": [
    "parts"
  ],
  "title": "Partition",
  "type": "object"
}

noether/combin/Poset@1

Python combin.Poset · Rust domain

The thin Python handle around Noether's validated Rust [Poset].

Canonical JSON Schema
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "covers": {
      "items": {
        "maxItems": 2,
        "minItems": 2,
        "prefixItems": [
          {
            "format": "uint32",
            "minimum": 0,
            "type": "integer"
          },
          {
            "format": "uint32",
            "minimum": 0,
            "type": "integer"
          }
        ],
        "type": "array"
      },
      "type": "array"
    },
    "order": {
      "format": "uint",
      "minimum": 0,
      "type": "integer"
    }
  },
  "required": [
    "order",
    "covers"
  ],
  "title": "Poset",
  "type": "object"
}

noether/combin/SymmetricFunction@1

Python combin.SymmetricFunction · Rust domain

A thin Python handle around Noether's exact rational symmetric function.

Canonical JSON Schema
{
  "$defs": {
    "Partition": {
      "properties": {
        "parts": {
          "items": {
            "format": "uint",
            "minimum": 0,
            "type": "integer"
          },
          "type": "array"
        }
      },
      "required": [
        "parts"
      ],
      "type": "object"
    },
    "SymmetricTermWire": {
      "properties": {
        "coefficient": {
          "type": "string"
        },
        "partition": {
          "$ref": "#/$defs/Partition"
        }
      },
      "required": [
        "partition",
        "coefficient"
      ],
      "type": "object"
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "basis": {
      "type": "string"
    },
    "terms": {
      "items": {
        "$ref": "#/$defs/SymmetricTermWire"
      },
      "type": "array"
    }
  },
  "required": [
    "basis",
    "terms"
  ],
  "title": "SymmetricFunction",
  "type": "object"
}

noether/combin/Tableau@1

Python combin.Tableau · Rust domain

A thin Python handle around Noether's semistandard integer tableau.

Canonical JSON Schema
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "rows": {
      "items": {
        "items": {
          "type": "string"
        },
        "type": "array"
      },
      "type": "array"
    }
  },
  "required": [
    "rows"
  ],
  "title": "Tableau",
  "type": "object"
}

noether/combin/Tree@1

Python combin.Tree · Rust domain

A rooted tree over graph-core's CSR graph.

Canonical JSON Schema
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "edges": {
      "items": {
        "maxItems": 2,
        "minItems": 2,
        "prefixItems": [
          {
            "format": "uint32",
            "minimum": 0,
            "type": "integer"
          },
          {
            "format": "uint32",
            "minimum": 0,
            "type": "integer"
          }
        ],
        "type": "array"
      },
      "type": "array"
    },
    "order": {
      "format": "uint",
      "minimum": 0,
      "type": "integer"
    },
    "root": {
      "format": "uint32",
      "minimum": 0,
      "type": "integer"
    }
  },
  "required": [
    "order",
    "edges",
    "root"
  ],
  "title": "Tree",
  "type": "object"
}

noether/commalg/PolynomialHomomorphism@1

Python commalg.PolynomialHomomorphism · Rust domain

A checked polynomial-ring homomorphism with explicit endpoints and images.

Canonical JSON Schema
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "coefficient_map": true,
    "images": {
      "items": true,
      "type": "array"
    },
    "source": true,
    "target": true,
    "type": {
      "type": "string"
    }
  },
  "required": [
    "type",
    "source",
    "target",
    "coefficient_map",
    "images"
  ],
  "title": "PolynomialHomomorphismWire",
  "type": "object"
}

noether/commalg/RationalFunctionFieldMap@1

Python commalg.RationalFunctionFieldMap · Rust domain

A checked coefficientwise map between finite rational-function fields.

Canonical JSON Schema
{
  "$defs": {
    "FiniteFieldWire": {
      "properties": {
        "characteristic": {
          "type": "string"
        },
        "modulus": {
          "items": {
            "format": "uint64",
            "minimum": 0,
            "type": "integer"
          },
          "type": [
            "array",
            "null"
          ]
        },
        "type": {
          "type": "string"
        }
      },
      "required": [
        "type",
        "characteristic"
      ],
      "type": "object"
    },
    "FiniteRationalFunctionFieldWire": {
      "properties": {
        "coefficient_ring": {
          "$ref": "#/$defs/FiniteFieldWire"
        },
        "type": {
          "type": "string"
        },
        "variable": {
          "type": "string"
        }
      },
      "required": [
        "type",
        "coefficient_ring",
        "variable"
      ],
      "type": "object"
    },
    "PrimeSubfieldEmbeddingWire": {
      "properties": {
        "source": {
          "$ref": "#/$defs/FiniteFieldWire"
        },
        "target": {
          "$ref": "#/$defs/FiniteFieldWire"
        },
        "type": {
          "type": "string"
        }
      },
      "required": [
        "type",
        "source",
        "target"
      ],
      "type": "object"
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "coefficient_map": {
      "$ref": "#/$defs/PrimeSubfieldEmbeddingWire"
    },
    "source": {
      "$ref": "#/$defs/FiniteRationalFunctionFieldWire"
    },
    "target": {
      "$ref": "#/$defs/FiniteRationalFunctionFieldWire"
    },
    "type": {
      "type": "string"
    }
  },
  "required": [
    "type",
    "source",
    "target",
    "coefficient_map"
  ],
  "title": "RationalFunctionFieldMapWire",
  "type": "object"
}

noether/groups/PolynomialGlRepresentation@1

Python groups.PolynomialGlRepresentation · Rust domain

The irreducible polynomial representation of GL indexed by a partition.

Canonical JSON Schema
{
  "$defs": {
    "Partition": {
      "properties": {
        "parts": {
          "items": {
            "format": "uint",
            "minimum": 0,
            "type": "integer"
          },
          "type": "array"
        }
      },
      "required": [
        "parts"
      ],
      "type": "object"
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "partition": {
      "$ref": "#/$defs/Partition"
    },
    "rank": {
      "format": "uint",
      "minimum": 0,
      "type": "integer"
    },
    "type": {
      "type": "string"
    }
  },
  "required": [
    "type",
    "rank",
    "partition"
  ],
  "title": "PolynomialGlRepresentation",
  "type": "object"
}

noether/groups/WeightCharacter@1

Python groups.WeightCharacter · Rust domain

A finite formal character on an explicit weight lattice.

Canonical JSON Schema
{
  "$defs": {
    "WeightBasisConventionWire": {
      "oneOf": [
        {
          "enum": [
            "standard"
          ],
          "type": "string"
        },
        {
          "additionalProperties": false,
          "properties": {
            "type_a_fundamental": {
              "properties": {
                "degree": {
                  "format": "uint",
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "required": [
                "degree"
              ],
              "type": "object"
            }
          },
          "required": [
            "type_a_fundamental"
          ],
          "type": "object"
        }
      ]
    },
    "WeightLattice": {
      "properties": {
        "basis_names": {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "convention": {
          "$ref": "#/$defs/WeightBasisConventionWire"
        },
        "type": {
          "type": "string"
        }
      },
      "required": [
        "type",
        "basis_names",
        "convention"
      ],
      "type": "object"
    },
    "WeightMultiplicitySchema": {
      "properties": {
        "multiplicity": {
          "type": "string"
        },
        "weight": {
          "items": {
            "type": "string"
          },
          "type": "array"
        }
      },
      "required": [
        "weight",
        "multiplicity"
      ],
      "type": "object"
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "lattice": {
      "$ref": "#/$defs/WeightLattice"
    },
    "terms": {
      "items": {
        "$ref": "#/$defs/WeightMultiplicitySchema"
      },
      "type": "array"
    },
    "type": {
      "type": "string"
    }
  },
  "required": [
    "type",
    "lattice",
    "terms"
  ],
  "title": "WeightCharacter",
  "type": "object"
}

noether/groups/WeightLattice@1

Python groups.WeightLattice · Rust domain

A free weight lattice with a named basis and an explicit basis convention.

Canonical JSON Schema
{
  "$defs": {
    "WeightBasisConventionWire": {
      "oneOf": [
        {
          "enum": [
            "standard"
          ],
          "type": "string"
        },
        {
          "additionalProperties": false,
          "properties": {
            "type_a_fundamental": {
              "properties": {
                "degree": {
                  "format": "uint",
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "required": [
                "degree"
              ],
              "type": "object"
            }
          },
          "required": [
            "type_a_fundamental"
          ],
          "type": "object"
        }
      ]
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "basis_names": {
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "convention": {
      "$ref": "#/$defs/WeightBasisConventionWire"
    },
    "type": {
      "type": "string"
    }
  },
  "required": [
    "type",
    "basis_names",
    "convention"
  ],
  "title": "WeightLattice",
  "type": "object"
}

noether/groups/WeightLatticeMap@1

Python groups.WeightLatticeMap · Rust domain

A homomorphism between two explicit weight lattices.

Canonical JSON Schema
{
  "$defs": {
    "WeightBasisConventionWire": {
      "oneOf": [
        {
          "enum": [
            "standard"
          ],
          "type": "string"
        },
        {
          "additionalProperties": false,
          "properties": {
            "type_a_fundamental": {
              "properties": {
                "degree": {
                  "format": "uint",
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "required": [
                "degree"
              ],
              "type": "object"
            }
          },
          "required": [
            "type_a_fundamental"
          ],
          "type": "object"
        }
      ]
    },
    "WeightLattice": {
      "properties": {
        "basis_names": {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "convention": {
          "$ref": "#/$defs/WeightBasisConventionWire"
        },
        "type": {
          "type": "string"
        }
      },
      "required": [
        "type",
        "basis_names",
        "convention"
      ],
      "type": "object"
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "basis_images": {
      "items": {
        "items": {
          "type": "string"
        },
        "type": "array"
      },
      "type": "array"
    },
    "source": {
      "$ref": "#/$defs/WeightLattice"
    },
    "target": {
      "$ref": "#/$defs/WeightLattice"
    },
    "type": {
      "type": "string"
    }
  },
  "required": [
    "type",
    "source",
    "target",
    "basis_images"
  ],
  "title": "WeightLatticeMap",
  "type": "object"
}

noether/homalg/ExteriorAlgebra@1

Python homalg.ExteriorAlgebra · Rust domain

The exact exterior-algebra parent of a finite based free module.

Canonical JSON Schema
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "source": true,
    "type": {
      "type": "string"
    }
  },
  "required": [
    "type",
    "source"
  ],
  "title": "ExteriorAlgebra",
  "type": "object"
}

noether/homalg/ExteriorElement@1

Python homalg.ExteriorElement · Rust domain

A canonical sparse, possibly inhomogeneous, exact exterior-algebra element.

Canonical JSON Schema
{
  "$defs": {
    "ExteriorAlgebra": {
      "properties": {
        "source": true,
        "type": {
          "type": "string"
        }
      },
      "required": [
        "type",
        "source"
      ],
      "type": "object"
    },
    "ExteriorTermSchema": {
      "properties": {
        "basis": {
          "items": {
            "format": "uint",
            "minimum": 0,
            "type": "integer"
          },
          "type": "array"
        },
        "coefficient": true
      },
      "required": [
        "basis",
        "coefficient"
      ],
      "type": "object"
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "algebra": {
      "$ref": "#/$defs/ExteriorAlgebra"
    },
    "terms": {
      "items": {
        "$ref": "#/$defs/ExteriorTermSchema"
      },
      "type": "array"
    },
    "type": {
      "type": "string"
    }
  },
  "required": [
    "type",
    "algebra",
    "terms"
  ],
  "title": "ExteriorElement",
  "type": "object"
}

noether/homalg/FinitelyGeneratedAbelianGroup@1

Python homalg.FinitelyGeneratedAbelianGroup · Rust domain

A finitely generated abelian group in canonical invariant-factor form.

Canonical JSON Schema
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "free_rank": {
      "format": "uint",
      "minimum": 0,
      "type": "integer"
    },
    "torsion_coefficients": {
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "type": {
      "type": "string"
    }
  },
  "required": [
    "type",
    "free_rank",
    "torsion_coefficients"
  ],
  "title": "FinitelyGeneratedAbelianGroup",
  "type": "object"
}

noether/homalg/ImageSubmodule@1

Python homalg.ImageSubmodule · Rust domain

A map-bound certificate for a complete exact image.

Canonical JSON Schema
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "homomorphism": true,
    "submodule": true,
    "type": {
      "type": "string"
    }
  },
  "required": [
    "type",
    "homomorphism",
    "submodule"
  ],
  "title": "ImageSubmodule",
  "type": "object"
}

noether/homalg/KernelSubmodule@1

Python homalg.KernelSubmodule · Rust domain

A map-bound certificate for a complete exact kernel.

Canonical JSON Schema
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "homomorphism": true,
    "submodule": true,
    "type": {
      "type": "string"
    }
  },
  "required": [
    "type",
    "homomorphism",
    "submodule"
  ],
  "title": "KernelSubmodule",
  "type": "object"
}

noether/homalg/ModulePowerHomomorphism@1

Python homalg.ModulePowerHomomorphism · Rust domain

A replay-verifiable map induced on a symmetric or exterior power.

Canonical JSON Schema
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "degree": {
      "format": "uint",
      "minimum": 0,
      "type": "integer"
    },
    "induced": true,
    "kind": {
      "type": "string"
    },
    "source_map": true,
    "source_power": true,
    "target_power": true,
    "type": {
      "type": "string"
    }
  },
  "required": [
    "type",
    "source_map",
    "kind",
    "degree",
    "source_power",
    "target_power",
    "induced"
  ],
  "title": "ModulePowerHomomorphism",
  "type": "object"
}

noether/homalg/PresentedModulePowerHomomorphism@1

Python homalg.PresentedModulePowerHomomorphism · Rust domain

A replay-verifiable induced map between symmetric or exterior presentations.

Canonical JSON Schema
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "degree": {
      "format": "uint",
      "minimum": 0,
      "type": "integer"
    },
    "induced": true,
    "kind": {
      "type": "string"
    },
    "source_map": true,
    "source_power": true,
    "target_power": true,
    "type": {
      "type": "string"
    }
  },
  "required": [
    "type",
    "source_map",
    "kind",
    "degree",
    "source_power",
    "target_power",
    "induced"
  ],
  "title": "PresentedModulePowerHomomorphism",
  "type": "object"
}

noether/numthy/FiniteFieldEmbedding@1

Python numthy.FiniteFieldEmbedding · Rust domain

An explicitly presented embedding between compatible finite fields.

Canonical JSON Schema
{
  "$defs": {
    "FiniteFieldElementWire": {
      "properties": {
        "coefficients": {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "field": {
          "$ref": "#/$defs/FiniteFieldWire"
        },
        "type": {
          "type": "string"
        }
      },
      "required": [
        "type",
        "field",
        "coefficients"
      ],
      "type": "object"
    },
    "FiniteFieldWire": {
      "properties": {
        "characteristic": {
          "type": "string"
        },
        "modulus": {
          "items": {
            "format": "uint64",
            "minimum": 0,
            "type": "integer"
          },
          "type": [
            "array",
            "null"
          ]
        },
        "type": {
          "type": "string"
        }
      },
      "required": [
        "type",
        "characteristic"
      ],
      "type": "object"
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "generator_image": {
      "$ref": "#/$defs/FiniteFieldElementWire"
    },
    "source": {
      "$ref": "#/$defs/FiniteFieldWire"
    },
    "target": {
      "$ref": "#/$defs/FiniteFieldWire"
    },
    "type": {
      "type": "string"
    }
  },
  "required": [
    "type",
    "source",
    "target",
    "generator_image"
  ],
  "title": "FiniteFieldEmbeddingWire",
  "type": "object"
}

noether/root/IntegerFiniteFieldMap@1

Python IntegerFiniteFieldMap · Rust domain

The canonical unital map from the integers into one finite field.

Canonical JSON Schema
{
  "$defs": {
    "FiniteFieldWire": {
      "properties": {
        "characteristic": {
          "type": "string"
        },
        "modulus": {
          "items": {
            "format": "uint64",
            "minimum": 0,
            "type": "integer"
          },
          "type": [
            "array",
            "null"
          ]
        },
        "type": {
          "type": "string"
        }
      },
      "required": [
        "type",
        "characteristic"
      ],
      "type": "object"
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "target": {
      "$ref": "#/$defs/FiniteFieldWire"
    },
    "type": {
      "type": "string"
    }
  },
  "required": [
    "type",
    "target"
  ],
  "title": "IntegerFiniteFieldMapWire",
  "type": "object"
}

noether/root/IntegerRationalEmbedding@1

Python IntegerRationalEmbedding · Rust domain

The canonical embedding of the integers into the rationals.

Canonical JSON Schema
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "type": {
      "type": "string"
    }
  },
  "required": [
    "type"
  ],
  "title": "SingletonMapWire",
  "type": "object"
}

noether/root/IntegerReduction@1

Python IntegerReduction · Rust domain

Canonical reduction from the integers into one residue ring.

Canonical JSON Schema
{
  "$defs": {
    "ResidueRingWire": {
      "properties": {
        "modulus": {
          "type": "string"
        },
        "type": {
          "type": "string"
        }
      },
      "required": [
        "type",
        "modulus"
      ],
      "type": "object"
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "target": {
      "$ref": "#/$defs/ResidueRingWire"
    },
    "type": {
      "type": "string"
    }
  },
  "required": [
    "type",
    "target"
  ],
  "title": "IntegerReductionWire",
  "type": "object"
}

noether/root/PrimeSubfieldEmbedding@1

Python PrimeSubfieldEmbedding · Rust domain

The checked canonical embedding of a prime field into an extension field.

Canonical JSON Schema
{
  "$defs": {
    "FiniteFieldWire": {
      "properties": {
        "characteristic": {
          "type": "string"
        },
        "modulus": {
          "items": {
            "format": "uint64",
            "minimum": 0,
            "type": "integer"
          },
          "type": [
            "array",
            "null"
          ]
        },
        "type": {
          "type": "string"
        }
      },
      "required": [
        "type",
        "characteristic"
      ],
      "type": "object"
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "source": {
      "$ref": "#/$defs/FiniteFieldWire"
    },
    "target": {
      "$ref": "#/$defs/FiniteFieldWire"
    },
    "type": {
      "type": "string"
    }
  },
  "required": [
    "type",
    "source",
    "target"
  ],
  "title": "PrimeSubfieldEmbeddingWire",
  "type": "object"
}

noether/topology/EilenbergMacLaneIntegralCohomology@1

Python topology.EilenbergMacLaneIntegralCohomology · Rust domain

Exact bounded additive integral cohomology of a symbolic K(A,n).

Canonical JSON Schema
{
  "$defs": {
    "EilenbergMacLaneIntegralHomology": {
      "properties": {
        "groups": {
          "items": {
            "$ref": "#/$defs/FinitelyGeneratedAbelianGroup"
          },
          "type": "array"
        },
        "max_degree": {
          "format": "uint",
          "minimum": 0,
          "type": "integer"
        },
        "space": {
          "$ref": "#/$defs/EilenbergMacLaneSpace"
        },
        "strategy": {
          "type": "string"
        },
        "type": {
          "type": "string"
        }
      },
      "required": [
        "type",
        "space",
        "max_degree",
        "groups",
        "strategy"
      ],
      "type": "object"
    },
    "EilenbergMacLaneSpace": {
      "properties": {
        "delooping_degree": {
          "format": "uint",
          "minimum": 0,
          "type": "integer"
        },
        "group": {
          "$ref": "#/$defs/FinitelyGeneratedAbelianGroup"
        },
        "type": {
          "type": "string"
        }
      },
      "required": [
        "type",
        "group",
        "delooping_degree"
      ],
      "type": "object"
    },
    "FinitelyGeneratedAbelianGroup": {
      "properties": {
        "free_rank": {
          "format": "uint",
          "minimum": 0,
          "type": "integer"
        },
        "torsion_coefficients": {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "type": {
          "type": "string"
        }
      },
      "required": [
        "type",
        "free_rank",
        "torsion_coefficients"
      ],
      "type": "object"
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "groups": {
      "items": {
        "$ref": "#/$defs/FinitelyGeneratedAbelianGroup"
      },
      "type": "array"
    },
    "homology": {
      "$ref": "#/$defs/EilenbergMacLaneIntegralHomology"
    },
    "type": {
      "type": "string"
    }
  },
  "required": [
    "type",
    "homology",
    "groups"
  ],
  "title": "EilenbergMacLaneIntegralCohomology",
  "type": "object"
}

noether/topology/EilenbergMacLaneIntegralCohomologyPresentation@1

Python topology.EilenbergMacLaneIntegralCohomologyPresentation · Rust domain

Complete integral cohomology-ring presentation of a symbolic K(A,n).

Canonical JSON Schema
{
  "$defs": {
    "EilenbergMacLaneIntegralCohomologyGeneratorWire": {
      "properties": {
        "degree": {
          "format": "uint32",
          "minimum": 0,
          "type": "integer"
        },
        "display_name": {
          "type": "string"
        },
        "id": {
          "type": "string"
        },
        "origin": {
          "$ref": "#/$defs/EilenbergMacLaneIntegralGeneratorOriginWire"
        }
      },
      "required": [
        "id",
        "degree",
        "display_name",
        "origin"
      ],
      "type": "object"
    },
    "EilenbergMacLaneIntegralCohomologyRelationTermWire": {
      "properties": {
        "coefficient": {
          "type": "string"
        },
        "exponents": {
          "items": {
            "format": "uint32",
            "minimum": 0,
            "type": "integer"
          },
          "type": "array"
        }
      },
      "required": [
        "coefficient",
        "exponents"
      ],
      "type": "object"
    },
    "EilenbergMacLaneIntegralCohomologyRelationWire": {
      "properties": {
        "terms": {
          "items": {
            "$ref": "#/$defs/EilenbergMacLaneIntegralCohomologyRelationTermWire"
          },
          "type": "array"
        }
      },
      "required": [
        "terms"
      ],
      "type": "object"
    },
    "EilenbergMacLaneIntegralGeneratorOriginWire": {
      "oneOf": [
        {
          "properties": {
            "component": {
              "format": "uint",
              "minimum": 0,
              "type": "integer"
            },
            "kind": {
              "const": "free_fundamental_class",
              "type": "string"
            }
          },
          "required": [
            "kind",
            "component"
          ],
          "type": "object"
        },
        {
          "properties": {
            "component": {
              "format": "uint",
              "minimum": 0,
              "type": "integer"
            },
            "kind": {
              "const": "integral_bockstein",
              "type": "string"
            },
            "modulus": {
              "type": "string"
            }
          },
          "required": [
            "kind",
            "component",
            "modulus"
          ],
          "type": "object"
        },
        {
          "properties": {
            "kind": {
              "const": "cyclic_tor_class",
              "type": "string"
            },
            "left_component": {
              "format": "uint",
              "minimum": 0,
              "type": "integer"
            },
            "order": {
              "type": "string"
            },
            "right_component": {
              "format": "uint",
              "minimum": 0,
              "type": "integer"
            }
          },
          "required": [
            "kind",
            "left_component",
            "right_component",
            "order"
          ],
          "type": "object"
        },
        {
          "properties": {
            "component": {
              "format": "uint",
              "minimum": 0,
              "type": "integer"
            },
            "kind": {
              "const": "second_delooping_fundamental_class",
              "type": "string"
            }
          },
          "required": [
            "kind",
            "component"
          ],
          "type": "object"
        }
      ]
    },
    "EilenbergMacLaneSpace": {
      "properties": {
        "delooping_degree": {
          "format": "uint",
          "minimum": 0,
          "type": "integer"
        },
        "group": {
          "$ref": "#/$defs/FinitelyGeneratedAbelianGroup"
        },
        "type": {
          "type": "string"
        }
      },
      "required": [
        "type",
        "group",
        "delooping_degree"
      ],
      "type": "object"
    },
    "FinitelyGeneratedAbelianGroup": {
      "properties": {
        "free_rank": {
          "format": "uint",
          "minimum": 0,
          "type": "integer"
        },
        "torsion_coefficients": {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "type": {
          "type": "string"
        }
      },
      "required": [
        "type",
        "free_rank",
        "torsion_coefficients"
      ],
      "type": "object"
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "coefficient_ring": {
      "type": "string"
    },
    "generators": {
      "items": {
        "$ref": "#/$defs/EilenbergMacLaneIntegralCohomologyGeneratorWire"
      },
      "type": "array"
    },
    "graded_commutative": {
      "type": "boolean"
    },
    "relations": {
      "items": {
        "$ref": "#/$defs/EilenbergMacLaneIntegralCohomologyRelationWire"
      },
      "type": "array"
    },
    "space": {
      "$ref": "#/$defs/EilenbergMacLaneSpace"
    },
    "strategy": {
      "type": "string"
    },
    "type": {
      "type": "string"
    }
  },
  "required": [
    "type",
    "space",
    "coefficient_ring",
    "graded_commutative",
    "generators",
    "relations",
    "strategy"
  ],
  "title": "EilenbergMacLaneIntegralCohomologyPresentation",
  "type": "object"
}

noether/topology/EilenbergMacLaneIntegralHomology@1

Python topology.EilenbergMacLaneIntegralHomology · Rust domain

Exact bounded integral homology of a symbolic K(A,n).

Canonical JSON Schema
{
  "$defs": {
    "EilenbergMacLaneSpace": {
      "properties": {
        "delooping_degree": {
          "format": "uint",
          "minimum": 0,
          "type": "integer"
        },
        "group": {
          "$ref": "#/$defs/FinitelyGeneratedAbelianGroup"
        },
        "type": {
          "type": "string"
        }
      },
      "required": [
        "type",
        "group",
        "delooping_degree"
      ],
      "type": "object"
    },
    "FinitelyGeneratedAbelianGroup": {
      "properties": {
        "free_rank": {
          "format": "uint",
          "minimum": 0,
          "type": "integer"
        },
        "torsion_coefficients": {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "type": {
          "type": "string"
        }
      },
      "required": [
        "type",
        "free_rank",
        "torsion_coefficients"
      ],
      "type": "object"
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "groups": {
      "items": {
        "$ref": "#/$defs/FinitelyGeneratedAbelianGroup"
      },
      "type": "array"
    },
    "max_degree": {
      "format": "uint",
      "minimum": 0,
      "type": "integer"
    },
    "space": {
      "$ref": "#/$defs/EilenbergMacLaneSpace"
    },
    "strategy": {
      "type": "string"
    },
    "type": {
      "type": "string"
    }
  },
  "required": [
    "type",
    "space",
    "max_degree",
    "groups",
    "strategy"
  ],
  "title": "EilenbergMacLaneIntegralHomology",
  "type": "object"
}

noether/topology/EilenbergMacLaneModularCohomology@1

Python topology.EilenbergMacLaneModularCohomology · Rust domain

A complete prime-field cohomology presentation of a symbolic K(A,n).

Canonical JSON Schema
{
  "$defs": {
    "AdmissibleCohomologyOperationWire": {
      "oneOf": [
        {
          "properties": {
            "kind": {
              "const": "mod_two",
              "type": "string"
            },
            "sequence": {
              "items": {
                "format": "uint32",
                "minimum": 0,
                "type": "integer"
              },
              "type": "array"
            }
          },
          "required": [
            "kind",
            "sequence"
          ],
          "type": "object"
        },
        {
          "properties": {
            "bocksteins": {
              "items": {
                "type": "boolean"
              },
              "type": "array"
            },
            "kind": {
              "const": "odd_primary",
              "type": "string"
            },
            "prime": {
              "format": "uint64",
              "minimum": 0,
              "type": "integer"
            },
            "reduced_powers": {
              "items": {
                "format": "uint32",
                "minimum": 0,
                "type": "integer"
              },
              "type": "array"
            }
          },
          "required": [
            "kind",
            "prime",
            "bocksteins",
            "reduced_powers"
          ],
          "type": "object"
        }
      ]
    },
    "EilenbergMacLaneCohomologyGeneratorWire": {
      "properties": {
        "degree": {
          "format": "uint32",
          "minimum": 0,
          "type": "integer"
        },
        "display_name": {
          "type": "string"
        },
        "id": {
          "type": "string"
        },
        "origin": {
          "$ref": "#/$defs/EilenbergMacLaneGeneratorOriginWire"
        }
      },
      "required": [
        "id",
        "degree",
        "display_name",
        "origin"
      ],
      "type": "object"
    },
    "EilenbergMacLaneCohomologyOperationWire": {
      "properties": {
        "operation": {
          "$ref": "#/$defs/AdmissibleCohomologyOperationWire"
        },
        "source_generator": {
          "format": "uint",
          "minimum": 0,
          "type": "integer"
        },
        "target": true
      },
      "required": [
        "operation",
        "source_generator",
        "target"
      ],
      "type": "object"
    },
    "EilenbergMacLaneGeneratorOriginWire": {
      "oneOf": [
        {
          "properties": {
            "component": {
              "format": "uint",
              "minimum": 0,
              "type": "integer"
            },
            "kind": {
              "const": "fundamental_class",
              "type": "string"
            }
          },
          "required": [
            "kind",
            "component"
          ],
          "type": "object"
        },
        {
          "properties": {
            "kind": {
              "const": "bockstein",
              "type": "string"
            },
            "source_generator": {
              "format": "uint",
              "minimum": 0,
              "type": "integer"
            }
          },
          "required": [
            "kind",
            "source_generator"
          ],
          "type": "object"
        },
        {
          "properties": {
            "component": {
              "format": "uint",
              "minimum": 0,
              "type": "integer"
            },
            "kind": {
              "const": "periodic_cyclic_class",
              "type": "string"
            },
            "primary_exponent": {
              "format": "uint",
              "minimum": 0,
              "type": "integer"
            }
          },
          "required": [
            "kind",
            "component",
            "primary_exponent"
          ],
          "type": "object"
        },
        {
          "properties": {
            "component": {
              "format": "uint",
              "minimum": 0,
              "type": "integer"
            },
            "fundamental_class_lifts_integrally": {
              "type": "boolean"
            },
            "kind": {
              "const": "admissible_steenrod_square",
              "type": "string"
            },
            "operation": {
              "$ref": "#/$defs/AdmissibleCohomologyOperationWire"
            }
          },
          "required": [
            "kind",
            "component",
            "operation",
            "fundamental_class_lifts_integrally"
          ],
          "type": "object"
        },
        {
          "properties": {
            "component": {
              "format": "uint",
              "minimum": 0,
              "type": "integer"
            },
            "fundamental_class_lifts_integrally": {
              "type": "boolean"
            },
            "kind": {
              "const": "admissible_odd_primary_operation",
              "type": "string"
            },
            "operation": {
              "$ref": "#/$defs/AdmissibleCohomologyOperationWire"
            }
          },
          "required": [
            "kind",
            "component",
            "operation",
            "fundamental_class_lifts_integrally"
          ],
          "type": "object"
        },
        {
          "properties": {
            "component": {
              "format": "uint",
              "minimum": 0,
              "type": "integer"
            },
            "kind": {
              "const": "higher_bockstein",
              "type": "string"
            },
            "primary_exponent": {
              "format": "uint",
              "minimum": 0,
              "type": "integer"
            }
          },
          "required": [
            "kind",
            "component",
            "primary_exponent"
          ],
          "type": "object"
        },
        {
          "properties": {
            "component": {
              "format": "uint",
              "minimum": 0,
              "type": "integer"
            },
            "kind": {
              "const": "admissible_steenrod_square_on_higher_primary_class",
              "type": "string"
            },
            "operation": {
              "$ref": "#/$defs/AdmissibleCohomologyOperationWire"
            },
            "primary_exponent": {
              "format": "uint",
              "minimum": 0,
              "type": "integer"
            },
            "source_is_higher_bockstein": {
              "type": "boolean"
            }
          },
          "required": [
            "kind",
            "component",
            "primary_exponent",
            "source_is_higher_bockstein",
            "operation"
          ],
          "type": "object"
        },
        {
          "properties": {
            "component": {
              "format": "uint",
              "minimum": 0,
              "type": "integer"
            },
            "kind": {
              "const": "admissible_odd_primary_operation_on_higher_primary_class",
              "type": "string"
            },
            "operation": {
              "$ref": "#/$defs/AdmissibleCohomologyOperationWire"
            },
            "primary_exponent": {
              "format": "uint",
              "minimum": 0,
              "type": "integer"
            },
            "source_is_higher_bockstein": {
              "type": "boolean"
            }
          },
          "required": [
            "kind",
            "component",
            "primary_exponent",
            "source_is_higher_bockstein",
            "operation"
          ],
          "type": "object"
        }
      ]
    },
    "EilenbergMacLaneSpace": {
      "properties": {
        "delooping_degree": {
          "format": "uint",
          "minimum": 0,
          "type": "integer"
        },
        "group": {
          "$ref": "#/$defs/FinitelyGeneratedAbelianGroup"
        },
        "type": {
          "type": "string"
        }
      },
      "required": [
        "type",
        "group",
        "delooping_degree"
      ],
      "type": "object"
    },
    "FinitelyGeneratedAbelianGroup": {
      "properties": {
        "free_rank": {
          "format": "uint",
          "minimum": 0,
          "type": "integer"
        },
        "torsion_coefficients": {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "type": {
          "type": "string"
        }
      },
      "required": [
        "type",
        "free_rank",
        "torsion_coefficients"
      ],
      "type": "object"
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "field": true,
    "generators": {
      "items": {
        "$ref": "#/$defs/EilenbergMacLaneCohomologyGeneratorWire"
      },
      "type": "array"
    },
    "operations": {
      "items": {
        "$ref": "#/$defs/EilenbergMacLaneCohomologyOperationWire"
      },
      "type": "array"
    },
    "presentation": true,
    "space": {
      "$ref": "#/$defs/EilenbergMacLaneSpace"
    },
    "strategy": {
      "type": "string"
    },
    "type": {
      "type": "string"
    }
  },
  "required": [
    "type",
    "space",
    "field",
    "presentation",
    "generators",
    "operations",
    "strategy"
  ],
  "title": "EilenbergMacLaneModularCohomology",
  "type": "object"
}

noether/topology/EilenbergMacLaneModularCohomologyTruncation@1

Python topology.EilenbergMacLaneModularCohomologyTruncation · Rust domain

A prime-field cohomology presentation exact through one degree.

Canonical JSON Schema
{
  "$defs": {
    "AdmissibleCohomologyOperationWire": {
      "oneOf": [
        {
          "properties": {
            "kind": {
              "const": "mod_two",
              "type": "string"
            },
            "sequence": {
              "items": {
                "format": "uint32",
                "minimum": 0,
                "type": "integer"
              },
              "type": "array"
            }
          },
          "required": [
            "kind",
            "sequence"
          ],
          "type": "object"
        },
        {
          "properties": {
            "bocksteins": {
              "items": {
                "type": "boolean"
              },
              "type": "array"
            },
            "kind": {
              "const": "odd_primary",
              "type": "string"
            },
            "prime": {
              "format": "uint64",
              "minimum": 0,
              "type": "integer"
            },
            "reduced_powers": {
              "items": {
                "format": "uint32",
                "minimum": 0,
                "type": "integer"
              },
              "type": "array"
            }
          },
          "required": [
            "kind",
            "prime",
            "bocksteins",
            "reduced_powers"
          ],
          "type": "object"
        }
      ]
    },
    "EilenbergMacLaneCohomologyGeneratorWire": {
      "properties": {
        "degree": {
          "format": "uint32",
          "minimum": 0,
          "type": "integer"
        },
        "display_name": {
          "type": "string"
        },
        "id": {
          "type": "string"
        },
        "origin": {
          "$ref": "#/$defs/EilenbergMacLaneGeneratorOriginWire"
        }
      },
      "required": [
        "id",
        "degree",
        "display_name",
        "origin"
      ],
      "type": "object"
    },
    "EilenbergMacLaneGeneratorOriginWire": {
      "oneOf": [
        {
          "properties": {
            "component": {
              "format": "uint",
              "minimum": 0,
              "type": "integer"
            },
            "kind": {
              "const": "fundamental_class",
              "type": "string"
            }
          },
          "required": [
            "kind",
            "component"
          ],
          "type": "object"
        },
        {
          "properties": {
            "kind": {
              "const": "bockstein",
              "type": "string"
            },
            "source_generator": {
              "format": "uint",
              "minimum": 0,
              "type": "integer"
            }
          },
          "required": [
            "kind",
            "source_generator"
          ],
          "type": "object"
        },
        {
          "properties": {
            "component": {
              "format": "uint",
              "minimum": 0,
              "type": "integer"
            },
            "kind": {
              "const": "periodic_cyclic_class",
              "type": "string"
            },
            "primary_exponent": {
              "format": "uint",
              "minimum": 0,
              "type": "integer"
            }
          },
          "required": [
            "kind",
            "component",
            "primary_exponent"
          ],
          "type": "object"
        },
        {
          "properties": {
            "component": {
              "format": "uint",
              "minimum": 0,
              "type": "integer"
            },
            "fundamental_class_lifts_integrally": {
              "type": "boolean"
            },
            "kind": {
              "const": "admissible_steenrod_square",
              "type": "string"
            },
            "operation": {
              "$ref": "#/$defs/AdmissibleCohomologyOperationWire"
            }
          },
          "required": [
            "kind",
            "component",
            "operation",
            "fundamental_class_lifts_integrally"
          ],
          "type": "object"
        },
        {
          "properties": {
            "component": {
              "format": "uint",
              "minimum": 0,
              "type": "integer"
            },
            "fundamental_class_lifts_integrally": {
              "type": "boolean"
            },
            "kind": {
              "const": "admissible_odd_primary_operation",
              "type": "string"
            },
            "operation": {
              "$ref": "#/$defs/AdmissibleCohomologyOperationWire"
            }
          },
          "required": [
            "kind",
            "component",
            "operation",
            "fundamental_class_lifts_integrally"
          ],
          "type": "object"
        },
        {
          "properties": {
            "component": {
              "format": "uint",
              "minimum": 0,
              "type": "integer"
            },
            "kind": {
              "const": "higher_bockstein",
              "type": "string"
            },
            "primary_exponent": {
              "format": "uint",
              "minimum": 0,
              "type": "integer"
            }
          },
          "required": [
            "kind",
            "component",
            "primary_exponent"
          ],
          "type": "object"
        },
        {
          "properties": {
            "component": {
              "format": "uint",
              "minimum": 0,
              "type": "integer"
            },
            "kind": {
              "const": "admissible_steenrod_square_on_higher_primary_class",
              "type": "string"
            },
            "operation": {
              "$ref": "#/$defs/AdmissibleCohomologyOperationWire"
            },
            "primary_exponent": {
              "format": "uint",
              "minimum": 0,
              "type": "integer"
            },
            "source_is_higher_bockstein": {
              "type": "boolean"
            }
          },
          "required": [
            "kind",
            "component",
            "primary_exponent",
            "source_is_higher_bockstein",
            "operation"
          ],
          "type": "object"
        },
        {
          "properties": {
            "component": {
              "format": "uint",
              "minimum": 0,
              "type": "integer"
            },
            "kind": {
              "const": "admissible_odd_primary_operation_on_higher_primary_class",
              "type": "string"
            },
            "operation": {
              "$ref": "#/$defs/AdmissibleCohomologyOperationWire"
            },
            "primary_exponent": {
              "format": "uint",
              "minimum": 0,
              "type": "integer"
            },
            "source_is_higher_bockstein": {
              "type": "boolean"
            }
          },
          "required": [
            "kind",
            "component",
            "primary_exponent",
            "source_is_higher_bockstein",
            "operation"
          ],
          "type": "object"
        }
      ]
    },
    "EilenbergMacLaneSpace": {
      "properties": {
        "delooping_degree": {
          "format": "uint",
          "minimum": 0,
          "type": "integer"
        },
        "group": {
          "$ref": "#/$defs/FinitelyGeneratedAbelianGroup"
        },
        "type": {
          "type": "string"
        }
      },
      "required": [
        "type",
        "group",
        "delooping_degree"
      ],
      "type": "object"
    },
    "FinitelyGeneratedAbelianGroup": {
      "properties": {
        "free_rank": {
          "format": "uint",
          "minimum": 0,
          "type": "integer"
        },
        "torsion_coefficients": {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "type": {
          "type": "string"
        }
      },
      "required": [
        "type",
        "free_rank",
        "torsion_coefficients"
      ],
      "type": "object"
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "exact_through_degree": {
      "format": "uint",
      "minimum": 0,
      "type": "integer"
    },
    "field": true,
    "generators": {
      "items": {
        "$ref": "#/$defs/EilenbergMacLaneCohomologyGeneratorWire"
      },
      "type": "array"
    },
    "presentation": true,
    "space": {
      "$ref": "#/$defs/EilenbergMacLaneSpace"
    },
    "strategy": {
      "type": "string"
    },
    "type": {
      "type": "string"
    }
  },
  "required": [
    "type",
    "space",
    "field",
    "exact_through_degree",
    "presentation",
    "generators",
    "strategy"
  ],
  "title": "EilenbergMacLaneModularCohomologyTruncation",
  "type": "object"
}

noether/topology/EilenbergMacLaneSpace@1

Python topology.EilenbergMacLaneSpace · Rust domain

A symbolic Eilenberg--Mac Lane space K(A,n).

Canonical JSON Schema
{
  "$defs": {
    "FinitelyGeneratedAbelianGroup": {
      "properties": {
        "free_rank": {
          "format": "uint",
          "minimum": 0,
          "type": "integer"
        },
        "torsion_coefficients": {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "type": {
          "type": "string"
        }
      },
      "required": [
        "type",
        "free_rank",
        "torsion_coefficients"
      ],
      "type": "object"
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "delooping_degree": {
      "format": "uint",
      "minimum": 0,
      "type": "integer"
    },
    "group": {
      "$ref": "#/$defs/FinitelyGeneratedAbelianGroup"
    },
    "type": {
      "type": "string"
    }
  },
  "required": [
    "type",
    "group",
    "delooping_degree"
  ],
  "title": "EilenbergMacLaneSpace",
  "type": "object"
}