⚖️ SLANG-Voting

🗳️ What If Election Outcomes Were Released Only After the Declared Conditions Were Met?

Derive a bounded outcome from declared aggregate reports. Make it visible only when the declared conditions are met.

🗳️ SLANG-Voting

Election-result discussions often combine several very different questions:

Were ballots collected correctly?
Are the reported totals authentic?
Is the declared reporting boundary complete?
Do the aggregate records agree?
Which candidate follows from the declared rule?
Is the result admitted for visibility?
Can the result later be reconstructed and verified?

SLANG-Voting separates these questions.

The current reference does not process voter identities or individual ballots. It operates on declared aggregate reporting-unit records under an exact reporting boundary, versioned aggregation rules, versioned decision rules, and an explicit evidence mode.

Its central contract is:

same admitted canonical reports + same sealed reporting boundary + same versioned profile -> same bounded result state

The idea is deliberately narrow.

SLANG-Voting does not claim to establish whether the supplied reports are authentic, lawful, complete in the real world, or officially certifiable.

It asks a smaller structural question:

Given a declared set of aggregate reports and a declared rule profile, what bounded result state follows?

🌐 Explore SLANG-Voting on GitHub

📄 Aggregate Reports Are Not Ballots

The current reference begins after ballot-level activity.

The submitted structure contains reporting-unit records with:

candidate counts
non-candidate record count
total record count
reporting-unit identity

It also contains source-level declarations such as:

source identity
source commitment
declared report-set identity

The resolver does not determine:

who voted
whether a voter was eligible
whether a ballot was authentic
whether secrecy was preserved
whether the source system was secure
whether the records were lawfully certified

Those remain separate operational, institutional, legal, and security responsibilities.

SLANG-Voting evaluates the submitted aggregate structure.

That distinction matters:

aggregate structural resolution != ballot verification

🧩 What the Resolver Actually Checks

SLANG-Voting separates several questions that are often blended together:

Is the input inside the supported portable JSON boundary?
Are the declared candidates, sources, units, and rules supported?
Is the reporting boundary explicitly sealed?
Does every expected source provide every expected reporting unit?
Do the aggregate records reconcile internally?
Do declared structural identities match the computed identities?
Do multiple declared sources reproduce the same canonical report set?
Does the selected aggregation and decision rule justify a result?
Is the resolved outcome admitted for visibility?
Can the result be reconstructed from preserved evidence?

A simplified flow is:

submitted input -> admission -> normalization -> boundary closure -> source agreement -> aggregation -> decision -> visibility -> evidence

The resolver may return:

RESOLVED

INCOMPLETE

CONFLICT

FORBIDDEN

UNSUPPORTED

ABSTAIN

A non-result is not automatically an error.

It may mean that the submitted structure does not justify forcing an outcome.

🚦 A Result Is Not Forced

Consider a few examples.

If an expected reporting unit is missing:

missing declared unit -> INCOMPLETE

If a source reports an undeclared unit:

undeclared unit -> CONFLICT

If aggregate candidate counts do not reconcile with the declared total:

report-total mismatch -> CONFLICT

If the requested electoral method is outside the current profile:

unsupported method -> UNSUPPORTED

If the admitted reports produce a material tie:

unresolved supported decision -> ABSTAIN

If evaluation is prohibited:

evaluation_authorized = false -> FORBIDDEN

The practical principle is:

Resolve when the declared contract supports a result. Refuse when it does not.

🖼️ SLANG-Voting Reference Diagram

Figure: SLANG-Voting separates declared aggregate reports, reporting-boundary closure, deterministic outcome resolution, visibility handling, and verifiable evidence.

🔒 The Reporting Boundary Must Be Explicit

SLANG-Voting requires an exact expected reporting-unit set.

Conceptually:

reported_unit_set = expected_unit_set

A missing expected unit produces:

INCOMPLETE

An undeclared extra unit produces:

CONFLICT

The submitted context must also declare:

reporting_boundary_sealed = true

This prevents a currently available partial dataset from being treated as though the bounded declared contest were complete.

But the word declared is important.

A sealed reference boundary does not prove that every real-world reporting unit has actually been identified or reported.

The distinction is:

sealed declared boundary != proven real-world completeness

➕ How Are Aggregate Records Combined?

The current reference supports two bounded aggregation families.

1. Sum Counts

SUM_COUNTS

For each candidate:

resolution_total(c) = sum(unit_count(u, c) for every expected unit u)

This represents a bounded direct-count aggregation when the supplied records and declared local rule mapping are appropriate.

2. Unit Winner Weight

UNIT_WINNER_WEIGHT

Each reporting unit declares candidate counts and a positive unit weight.

The full unit weight is assigned to the unique local leader.

Conceptually:

resolution_total(c) = sum(unit_weight(u) for units uniquely won by c)

If any unit has a tied local lead, the reference does not invent a tie-break procedure or silently discard the unit.

It returns:

ABSTAIN / UNIT_LOCAL_TIE

This is one bounded winner-takes-unit-weight profile. It is not a claim about every unit-based electoral system.

🎯 How Is the Bounded Result Selected?

The current reference supports three decision families.

Unique Maximum

UNIQUE_MAX

A result resolves only when one candidate has the unique highest resolution total.

selected = unique argmax_c resolution_total(c)

A top tie produces:

ABSTAIN / TOP_TIE

Absolute Majority

ABSOLUTE_MAJORITY

A result resolves only when one candidate has more than half of the total resolution quantity.

2 * top_total > total_resolution_quantity

Otherwise:

ABSTAIN / NO_ABSOLUTE_MAJORITY

The resolver does not automatically schedule or infer another round.

Top K

TOP_K

The resolver selects the highest k candidates only when the final selection boundary is unambiguous.

selection_boundary_tie -> ABSTAIN

Candidate identifier order is never used to break a material tie.

🧠 `ABSTAIN` Does Not Mean a Voter Abstained

In SLANG-Voting, ABSTAIN is a resolver state.

It means that the admitted complete structure does not justify an unambiguous outcome under the supported decision rule.

Examples include:

a top tie
no absolute majority
a tie crossing the TOP_K boundary
a tied local unit
zero total resolution quantity

It is not a voter-choice label.

Non-candidate records use a separate field:

non_candidate_count

🔁 What Does Multi-Source Agreement Mean?

SLANG-Voting supports:

SINGLE_SOURCE

and:

MULTI_SOURCE_EXACT_AGREEMENT

Under exact multi-source agreement, every declared source must supply a complete normalized report set.

The resolver requires:

report_set_id(source_1) = ... = report_set_id(source_n)

and:

canonical_reports(source_1) = ... = canonical_reports(source_n)

If one source disagrees, the resolver returns:

CONFLICT

This mode is best understood as a replication and integrity check.

It asks:

Do all declared sources reproduce the same normalized report set?

It is not:

a quorum mechanism
a majority mechanism
a reconciliation process
an error-correction system
proof of source independence
proof of source authenticity

One disagreeing source is not ignored, and the current profile does not select the largest agreeing group.

A future profile could explore a separately defined mode such as:

M_OF_N_EXACT_AGREEMENT

But no quorum mode is supported by SLANG-Voting v0.1.2.

👁️ Resolution and Visibility Are Different Decisions

One of the most important distinctions in SLANG-Voting is:

resolution != visibility

A bounded outcome may resolve while the public presentation remains withheld.

For example:

resolution_state = RESOLVED

state = FORBIDDEN

visibility_state = WITHHOLD

outcome_visible = false

The full result, reconstruction bundle, and receipt may retain selected candidates, totals, and structural identities for verification.

The visibility-aware public summary sets candidate-bearing fields to null:

selected_candidate_ids = null

leading_candidate_ids = null

candidate_resolution_totals = null

This is a presentation boundary.

It is not encryption, confidentiality, access control, or an official embargo mechanism.

The distinction is:

A bounded result may exist without being admitted for exposure through the public summary.

🧾 The Result Can Carry Verifiable Evidence

SLANG-Voting constructs deterministic identities for supported structures and results.

These include:

submission identity
canonical-input identity
candidate-set identity
reporting-boundary identity
report-set identity
rule-profile identity
source-manifest identity
source-agreement identity
outcome identity
evaluation-evidence identity
result identity
bundle identity
receipt identity

Each structural identity follows the general form:

identity = prefix + sha256(canonical_json(preimage))

These identities bind declared structures together.

They do not prove that an external source is trustworthy or that a real election is legally valid.

🔍 Submitted Form and Normalized Meaning Are Both Preserved

SLANG-Voting preserves two views of the input.

The original admitted structure is bound by:

submission_id

The normalized semantic projection is bound by:

canonical_input_id

Identifiers are trimmed and converted to uppercase before semantic validation.

For example:

" source-a " -> SOURCE-A

"candidate-a" -> CANDIDATE-A

If two submitted identifiers normalize to the same value, they cannot coexist as distinct identifiers.

For example:

candidate-a + CANDIDATE-A -> CONFLICT

This permits deterministic canonical comparison while preserving the submitted form separately.

🔄 Bundles and Receipts

A reconstruction bundle preserves:

the submitted input
the normalized projection
the complete result
reconstruction evidence
the bundle identity

Bundle verification reconstructs the result from the preserved submitted input and requires exact canonical agreement.

A compact receipt carries principal states, identities, modes, authority boundaries, and bundle binding without repeating every aggregate record.

Receipt verification checks the receipt’s integrity.

Receipt-to-bundle verification checks that the receipt belongs to the supplied reconstruction bundle.

The broader idea is:

A resolver should not merely announce a result. It should preserve enough declared structure to inspect what the result means.

🧮 Semantic Identity Is Not the Same as File-Byte Identity

SLANG-Voting distinguishes structural identity from deterministic file serialization.

Structural identity preimages use compact ASCII-canonical JSON:

sorted keys
escaped non-ASCII characters
no insignificant whitespace

Generated evidence files use readable UTF-8 JSON:

native Unicode characters
two-space indentation
sorted keys
LF line endings
exactly one terminal LF
no byte-order mark

Therefore:

structural identity != raw file checksum

Hashing the visible file bytes will not reproduce an embedded structural identity unless that value is explicitly defined as a file checksum.

The vector generator nevertheless uses a deterministic writer, so the same supported vector object reproduces the same file bytes across supported operating systems.

⚖️ Does a Resolved Result Prove Election Correctness?

No.

SLANG-Voting does not verify:

ballots
voters
voter eligibility
voter identity
ballot secrecy
coercion resistance
secure voting hardware
secure transmission
source authenticity
digital signatures
chain of custody
recount correctness
audit sampling
fraud detection
legal compliance
constitutional authority
official certification
democratic legitimacy

It resolves only the admitted declared aggregate structure.

Important distinctions include:

source commitment syntax != provenance

multi-source exact agreement != source independence

bundle reconstruction != source truth

receipt verification != official correctness

public-summary redaction != confidentiality

🌍 Where Could This Approach Be Explored?

The structural pattern could be studied for bounded aggregate-result settings such as:

constituency-level result resolution
unit-weight result models
multi-seat TOP_K structures
parallel report replication checks
visibility-controlled reference publication
reconstruction and audit of declared result inputs
deterministic testing of jurisdiction-specific profiles

The useful question is not:

Can this resolver replace an election system?

It cannot.

The useful question is:

Can a declared aggregate result be resolved reproducibly, refused explicitly, and preserved with inspectable evidence under a precise bounded contract?

SLANG-Voting provides one reference for studying that question.

🧪 Current Reference Status

The current reference is SLANG-Voting v0.1.2.

Published checks include:

209/209 PASS permanent reference audit
49/49 semantic vectors reproduced
4/4 presentation vectors reproduced
8/8 strict-parser vectors reproduced
3/3 reference-evidence checks reproduced
1/1 canonical serialization-byte check reproduced
8/8 metamorphic relations reproduced
canonical bundle verification: PASS
canonical receipt verification: PASS
receipt-to-bundle binding: PASS

The repository includes:

the Python reference implementation
the frozen conformance vectors
a canonical example input
a reconstruction bundle
a compact receipt
the normative bounded profile
the reference diagram
verification and regeneration commands
permanent hostile-input, precedence, tamper, visibility, and serialization coverage

These results apply only to the declared v0.1.2 implementation, schemas, profile, ruleset, limits, inputs, and evidence boundary.

⚠️ What SLANG-Voting Does — and Does Not — Claim

SLANG-Voting demonstrates:

bounded aggregate-record admission
exact reporting-boundary closure
deterministic aggregation under declared modes
deterministic decision under declared rules
explicit refusal and non-result states
exact multi-source replication checks
resolution and visibility separation
visibility-aware public summaries
deterministic structural identities
reconstruction bundles
compact receipts
frozen conformance vectors
byte-reproducible generated artifacts

It does not provide:

a voting platform
ballot collection
voter registration
voter authentication
ballot secrecy
source authentication
operational election security
recount execution
dispute resolution
legal certification
official publication
democratic legitimacy
support for every electoral method

Its claim is narrower:

same admitted canonical reports + same sealed reporting boundary + same versioned profile -> same bounded result state

missing declared structure -> INCOMPLETE

contradictory declared structure -> CONFLICT

complete structure without an unambiguous supported decision -> ABSTAIN

unsupported method or representation -> UNSUPPORTED

prohibited evaluation or visibility -> FORBIDDEN

🌐 Explore SLANG-Voting

The GitHub repository contains the reference implementation, frozen vectors, example input, bounded profile, reconstruction bundle, compact receipt, verification commands, architecture details, and reference diagram.

🔗 SLANG-Voting on GitHub

The SLANG-Voting reference implementation and verification artifacts are free to use, copy, modify, test, study, and redistribute without a license fee, subject to the repository LICENSE.

Architecture materials, documentation, specifications, diagrams, and explanatory content are subject to CC BY-NC 4.0 as stated in the LICENSE.

🌌 The Larger Question

Election systems necessarily involve participation, collection, counting, security, law, institutions, and public legitimacy.

SLANG-Voting does not attempt to replace those responsibilities.

It adds a narrower question:

Once declared aggregate reports exist, can the bounded result state be made deterministic, explicit, reconstructable, and safely withheld when the declared structure does not justify visibility?

The principle is:

Declare the boundary. Normalize the structure. Resolve only what the profile supports. Refuse unsafe certainty. Preserve evidence of what was resolved.

✍️ Authorship & Disclaimer

Created by the authors of the Shunyaya Framework.

SLANG-Voting is a bounded deterministic reference implementation for election-result resolution from declared aggregate records.

It is not a voting system, election standard, certification process, official publication mechanism, or result authority.

High-stakes use requires independent implementation review, security assessment, legal and constitutional analysis, appropriate institutional authorization, source-authenticity controls, privacy safeguards, and suitable operational governance.

OMP

🗳️ What If Election Outcomes Were Released Only After the Declared Conditions Were Met?

Derive a bounded outcome from declared aggregate reports. Make it visible only when the declared conditions are met.

🗳️ SLANG-Voting

📄 Aggregate Reports Are Not Ballots

🧩 What the Resolver Actually Checks

🚦 A Result Is Not Forced

🖼️ SLANG-Voting Reference Diagram

🔒 The Reporting Boundary Must Be Explicit

➕ How Are Aggregate Records Combined?

1. Sum Counts

2. Unit Winner Weight

🎯 How Is the Bounded Result Selected?

Unique Maximum

Absolute Majority

Top K

🧠 ABSTAIN Does Not Mean a Voter Abstained

🔁 What Does Multi-Source Agreement Mean?

👁️ Resolution and Visibility Are Different Decisions

🧾 The Result Can Carry Verifiable Evidence

🔍 Submitted Form and Normalized Meaning Are Both Preserved

🔄 Bundles and Receipts

🧮 Semantic Identity Is Not the Same as File-Byte Identity

⚖️ Does a Resolved Result Prove Election Correctness?

🌍 Where Could This Approach Be Explored?

🧪 Current Reference Status

⚠️ What SLANG-Voting Does — and Does Not — Claim

🌐 Explore SLANG-Voting

🌌 The Larger Question

✍️ Authorship & Disclaimer

🧠 `ABSTAIN` Does Not Mean a Voter Abstained