🥮 mooncakes.io

    moontally

    Auditable ranked-ballot counting with Schulze, Ranked Pairs and explicit IRV tie exploration

    Download zip
    Author
    Version
    0.1.0
    License
    MIT
    Repository
    Last updated
    7 hours ago
    Downloads
    3

    No dependencies

    #MoonTally

    MoonBit 原生排序投票计票与审计库。面向开源社区提案排序、社团方案选择和评审小组的加权偏好比较，提供逐步可复核的计票证据。

    支持有权重、并列名次及不完整选票的两两偏好矩阵；实现 Schulze（winning votes）、Ranked Pairs（明确强度排序规则）、严格排序 IRV。IRV 淘汰平票默认不擅自决定，可指定完整裁决顺序，也可枚举全部合法裁决下的可能赢家，并为每个赢家给出一条可重放的淘汰序列。

    #运行

    安装 MoonBit 工具链和 Node.js 24，在仓库目录执行：

    moon test --target js --deny-warn
npm run verify
node scripts/cli.mjs examples/panel.json

    Windows 可执行 powershell -File scripts/verify.ps1。CI 另外执行 Wasm、Wasm GC 和 Linux native 测试。Node 仅处理文件和 JSON；选票校验、矩阵、计票和审计证据均由 MoonBit 生成。

    #三个使用场景

    1. panel.json：加权评审小组比较三个方案；A 是两两比较均获胜的 Condorcet 赢家。
    2. club-cycle.json：社区成员形成 A>B、B>C、C>A 的循环偏好；Schulze 保留并列集合，Ranked Pairs 展示被拒绝的成环边及其路径。
    3. irv-tie.json：社团投票的淘汰平票；报告不同合法裁决可能产生的两名赢家，而不是掩盖不确定性。

    npm run examples 将真实结果写入 _build/reports/。独立路径穷举与 IRV 分支模型的验证记录也写入该目录。

    #安装与接口

    moon add forey217/moontally@0.1.0

    导入 forey217/moontally。见 独立消费者、规则契约、JSON 接口 和 验证说明。API 清单在 pkg.generated.mbti。

    #范围

    这是离线计票核心，不提供身份认证、票据收集、匿名性或防篡改服务，也不实现 STV 多席位计票。计票变体和平票规则均明确声明；不声称符合任何地区的法定选举规范。输入权重为正整数，总权重最多十亿；无有效偏好的空选举不产生赢家。

    MIT。原始算法与同类项目检索记录见 contract.md。

    TallyError

    source
    pub(all) suberror TallyError {
      Invalid(String)
      Limit(String)
    } derive(Eq, 
    Debug    )

    TallyError::equal

    source
    fn TallyError::equal(TallyError, TallyError) -> Bool

    TallyError::not_equal

    source
    fn TallyError::not_equal(x : TallyError, y : TallyError) -> Bool

    TallyError::to_repr

    source

    Ballot

    source
    pub(all) struct Ballot {
      weight : Int
      ranking : Array[Array[String]]
    } derive(Eq, 
    Debug    )

    Ballot::equal

    source
    fn Ballot::equal(Ballot, Ballot) -> Bool

    Ballot::not_equal

    source
    fn Ballot::not_equal(x : Ballot, y : Ballot) -> Bool

    Ballot::to_repr

    source

    Beatpath

    source
    pub(all) struct Beatpath {
      from : String
      to : String
      strength : Int
      path : Array[String]
    } derive(Eq, ToJson, 
    Debug    )

    Beatpath::equal

    source
    fn Beatpath::equal(Beatpath, Beatpath) -> Bool

    Beatpath::not_equal

    source
    fn Beatpath::not_equal(x : Beatpath, y : Beatpath) -> Bool

    Beatpath::to_json

    source
    fn Beatpath::to_json(Beatpath) -> Json

    Beatpath::to_repr

    source

    Election

    source
    pub struct Election {
      // private fields
    }

    Election::candidates

    source
    fn Election::candidates(self : Election) -> Array[String]

    Election::condorcet

    source
    fn Election::condorcet(self : Election) -> Array[String]

    Election::irv

    source
    fn Election::irv(self : Election, tie_order : Array[String]) -> IrvResult raise TallyError

    Without an explicit full tie-order permutation, an elimination tie is returned unresolved.

    Election::irv_possibilities

    source
    fn Election::irv_possibilities(self : Election, max_states : Int) -> IrvPossibilities raise TallyError

    Enumerates all legal single-elimination tie resolutions, memoizing active-candidate masks. A state budget exhaustion returns Limit rather than an incomplete winner set.

    Election::pairwise

    source
    fn Election::pairwise(self : Election) -> Array[Array[Int]]

    Election::ranked_pairs

    source
    fn Election::ranked_pairs(self : Election) -> RankedPairsResult

    Ranked Pairs variant: margin descending, winning votes descending, then lexical IDs. The deterministic equal-strength priority is explicit and is not parallel-universe RP.

    Election::schulze

    source
    fn Election::schulze(self : Election) -> SchulzeResult

    Schulze winning-votes variant. Returns the full unbeaten winner set; no hidden tie-break.

    Election::total_weight

    source
    fn Election::total_weight(self : Election) -> Int

    IrvPossibilities

    source
    pub(all) struct IrvPossibilities {
      possible_winners : Array[String]
      explored_states : Int
      witnesses : Array[TieWitness]
    } derive(Eq, ToJson, 
    Debug    )

    IrvPossibilities::equal

    source

    IrvPossibilities::not_equal

    source
    fn IrvPossibilities::not_equal(x : IrvPossibilities, y : IrvPossibilities) -> Bool

    IrvPossibilities::to_json

    source

    IrvPossibilities::to_repr

    source

    IrvResult

    source
    pub(all) struct IrvResult {
      winners : Array[String]
      rounds : Array[Round]
      needs_tiebreak : Bool
    } derive(Eq, ToJson, 
    Debug    )

    IrvResult::equal

    source
    fn IrvResult::equal(IrvResult, IrvResult) -> Bool

    IrvResult::not_equal

    source
    fn IrvResult::not_equal(x : IrvResult, y : IrvResult) -> Bool

    IrvResult::to_json

    source
    fn IrvResult::to_json(IrvResult) -> Json

    IrvResult::to_repr

    source

    LockedEdge

    source
    pub(all) struct LockedEdge {
      from : String
      to : String
      margin : Int
      winning_votes : Int
      locked : Bool
      cycle_path : Array[String]
    } derive(Eq, ToJson, 
    Debug    )

    LockedEdge::equal

    source
    fn LockedEdge::equal(LockedEdge, LockedEdge) -> Bool

    LockedEdge::not_equal

    source
    fn LockedEdge::not_equal(x : LockedEdge, y : LockedEdge) -> Bool

    LockedEdge::to_json

    source
    fn LockedEdge::to_json(LockedEdge) -> Json

    LockedEdge::to_repr

    source

    RankedPairsResult

    source
    pub(all) struct RankedPairsResult {
      winners : Array[String]
      decisions : Array[LockedEdge]
    } derive(Eq, ToJson, 
    Debug    )

    RankedPairsResult::equal

    source

    RankedPairsResult::not_equal

    source
    fn RankedPairsResult::not_equal(x : RankedPairsResult, y : RankedPairsResult) -> Bool

    RankedPairsResult::to_json

    source

    RankedPairsResult::to_repr

    source

    Round

    source
    pub(all) struct Round {
      active : Array[String]
      counts : Map[String, Int]
      continuing_weight : Int
      exhausted_weight : Int
      tied_lowest : Array[String]
      eliminated : String
    } derive(Eq, ToJson, 
    Debug    )

    Round::equal

    source
    fn Round::equal(Round, Round) -> Bool

    Round::not_equal

    source
    fn Round::not_equal(x : Round, y : Round) -> Bool

    Round::to_json

    source
    fn Round::to_json(Round) -> Json

    Round::to_repr

    source

    SchulzeResult

    source
    pub(all) struct SchulzeResult {
      winners : Array[String]
      strengths : Array[Array[Int]]
      witnesses : Array[Beatpath]
    } derive(Eq, ToJson, 
    Debug    )

    SchulzeResult::equal

    source

    SchulzeResult::not_equal

    source
    fn SchulzeResult::not_equal(x : SchulzeResult, y : SchulzeResult) -> Bool

    SchulzeResult::to_json

    source

    SchulzeResult::to_repr

    source

    TieWitness

    source
    pub(all) struct TieWitness {
      winner : String
      eliminations : Array[String]
    } derive(Eq, ToJson, 
    Debug    )

    TieWitness::equal

    source
    fn TieWitness::equal(TieWitness, TieWitness) -> Bool

    TieWitness::not_equal

    source
    fn TieWitness::not_equal(x : TieWitness, y : TieWitness) -> Bool

    TieWitness::to_json

    source
    fn TieWitness::to_json(TieWitness) -> Json

    TieWitness::to_repr

    source

    election

    source
    fn election(candidates : Array[String], ballots : Array[Ballot]) -> Election raise TallyError

    run_json

    source
    fn run_json(request : String) -> String

    Source Files

    Powered by MoonBit

    Site sourceReport issueModulesSkillsBuild queueStatistics

    © 2026 mooncakes.io