⚡ Can Financial State Be Resolved Without Moving Money?
Exact financial relationships become verifiable answers — without moving money, executing transactions, or trusting a single resolver.
💰 SLANG-Money
When we think about money systems, we usually think about transactions.
Money moves from one account to another.
A payment is executed.
A settlement system updates balances.
A bank or payment network records the result.
SLANG-Money starts with a different question:
What if some financial answers can be determined from the relationships that are already declared — before anything is executed?
That is the idea behind SLANG-Money v2.0.0.
It is a bounded, exact structural financial resolver.
The basic relation is:
declared financial structure -> structural closure -> bounded financial state -> portable certificate
And an important boundary comes first:
SLANG-Money moves no money, executes no transactions, contacts no bank, and carries no settlement or authorization authority.
🌐 Explore SLANG-Money on GitHub
🧩 SLANG-Money Structural Flow
Figure: Declared financial relationships are resolved using exact structural rules. The result may resolve, remain incomplete, abstain, or be refused — and the resulting certificate can be checked separately from the producer.
🧠 The Core Idea
Suppose we declare:
A_initial = 10000
B_initial = 10000
delta_A = -5000
delta_B = 5000
along with structural relationships connecting the initial values, changes, and final values.
No transfer is executed.
No account is contacted.
No settlement occurs.
Yet the structure itself can force:
A_final = 5000
B_final = 15000
The important distinction is:
the software is not performing the financial event.
It is determining what follows mathematically from the declared structure.
The bundled deterministic demo resolves exactly this example, and the resulting bundle can be checked by the standalone verifier.
🔥 What Happens When the Answer Is Not Clear?
This is where the project becomes more interesting.
SLANG-Money does not force every input into an answer.
Its outcome contract is:
RESOLVED | INCOMPLETE | ABSTAIN | FORBIDDEN | UNSUPPORTED
So if the structure uniquely determines the requested financial state:
RESOLVED
If information is missing:
INCOMPLETE
If the declarations contradict one another:
ABSTAIN
If an input violates the declared contract:
FORBIDDEN or UNSUPPORTED
That means the system is designed to distinguish:
answer exists
from:
answer is not justified
💵 Exact Money Means No Silent Rounding
SLANG-Money works with exact integer monetary facts in caller-declared minor units such as:
USD_CENT
INR_PAISE
Structural coefficients can also be exact fractions.
For example:
fee = 29/1000 * gross
If a requested result would require half of an indivisible minor unit:
2*x = 1
SLANG-Money does not quietly round it.
It returns:
ABSTAIN
NONINTEGRAL_MONEY_TARGET
That may sound like a small detail, but in financial computation it is an important discipline:
do not manufacture precision that the declared monetary unit does not support.
🧾 What Does “Proof-Carrying” Mean?
SLANG-Money does not simply output a number and ask the reader to trust it.
A resolved target carries a mathematical witness.
Conceptually:
w^T * A = e_t^T
w^T * b = value_t
That witness shows why the target value follows from the submitted structural equations.
If the declarations conflict, a contradiction witness can establish:
c^T * A = 0
c^T * b != 0
And if a target is not uniquely determined, an ambiguity direction can establish:
A*d = 0
d_target != 0
In simpler terms:
the certificate carries evidence for why the result — or refusal — is justified.
🔍 The Verifier Does Not Just Trust the Hash
This is an important part of v2.0.0.
The repository contains two standalone verification paths:
- a Python verifier
- a separately implemented JavaScript verifier
Neither imports or calls the producer resolver.
Both reconstruct the certificate semantics and check the structural witness.
So changing a result and simply recomputing the hashes is not enough.
The false result still has to satisfy the mathematics.
The current frozen cross-language conformance gate reports:
32/32 PASS
and includes deliberately rehashed semantic-forgery cases that both verification paths reject.
🌍 One Kernel, Different Financial Structures
The same frozen resolver has also been exercised across different bounded financial structures, including:
- fee and net-payment resolution
- multi-party allocation
- conservation-based reconstruction
- proportional settlement structure
- discount, tax, and net decomposition
- account-balance reconstruction
It also tests cases that should not resolve:
- underdetermined allocation
- contradictory declarations
- cross-unit relationships
- non-integral minor-unit targets
Current structural application-transfer result:
85/85 PASS
This is useful because the test is not:
one example -> one answer
It is:
one frozen structural kernel -> different bounded financial structures -> resolution or explicit refusal
🧪 What About Random Cases?
The project also includes a separate randomized differential test.
Small exact systems are generated and compared against a separately implemented fraction-free Bareiss/Cramer exact solver.
Three current deterministic seeds produced:
seed 2000 -> 128 cases -> 642/642 PASS
seed 2001 -> 128 cases -> 642/642 PASS
seed 2002 -> 128 cases -> 642/642 PASS
Combined:
384/384 generated cases PASS
The randomized testing layer is intentionally kept outside the frozen checksum surface so the testing strategy can continue to evolve.
✅ Current Verification Snapshot
The current v2.0.0 release reports:
Core self-test: 70/70 PASS
Structural application transfer: 85/85 PASS
Python standalone verifier: 10/10 PASS
JavaScript standalone verifier: 10/10 PASS
Cross-language conformance: 32/32 PASS
Package verification: 146/146 PASS
Randomized generated cases: 384/384 PASS
The GitHub Actions workflow is also passing.
For the exact commands, frozen hashes, evidence files, examples, and verification contract, the GitHub repository is the best reference.
🛡️ What SLANG-Money Does Not Claim
SLANG-Money is not:
- a payment processor
- a banking system
- a settlement network
- an accounting authority
- a tax engine
- an exchange-rate service
- a legal or regulatory authority
- an audit-certification system
- production infrastructure for regulated finance
It does not authenticate banks, accounts, institutions, or financial sources.
It does not determine whether the declared financial facts are true in the real world.
Its job is narrower:
given an admitted bounded financial structure, determine exactly what that structure forces — or refuse to manufacture an answer when it does not.
Independent third-party reproduction remains:
INDEPENDENT_THIRD_PARTY_REPRODUCTION: OPEN
🌐 Explore the Full Project
The GitHub repository contains:
- the frozen reference resolver
- Python and JavaScript standalone verifiers
- structural application-transfer evidence
- frozen conformance vectors
- randomized differential testing
- example financial structures
- certificate documentation
- exact input contract
- integrity scope
- claim boundaries
- reproducibility guidance
🌐 SLANG-Money v2.0.0 on GitHub
🌌 The Larger Question
SLANG-Money ultimately asks a simple question:
When financial relationships are already sufficiently declared, does the answer always need to come from executing a transaction — or can some financial state be resolved directly from structure?
Within its bounded exact model, v2.0.0 shows that some answers can be structurally forced, some remain genuinely incomplete, and some declarations should be explicitly refused.
declared financial structure -> exact resolution/refusal -> mathematical witness -> portable certificate -> producer-independent verification
No money moved. No settlement executed. The structure either supports the answer — or it does not.
OMP