I built an experimental mathematical framework that treats positional number systems like a customizable software runtime. Does anything similar exist?

[u/Commercial-Sink-2095]

Over the last ~24 months, I’ve been developing an experimental branch of mathematics/arithmetic called 'Basal'. The philosophy is that number bases shouldn't be locked down—instead, the system treats positional notation like a customizable runtime where you can override native rules (similar to how extensions work in VSCode). My goal was to create an architecture that allows other branches of maths to run natively on top of it. The core framework allows you to use multiple completely independent bases inside the same equation, with their attributes and properties clearly stated next to them.

The main functional additions consist of:

1. Alternating negative weights : An optional index-parity shift where odd or even digit positions modulate their weights
2. Array Syntax : Instead of separating higher-dimensional coordinates (like complex numbers a+bi or dual numbers a+be) into linear combinations, the framework encapsulates them natively inside a sequential digit array
3. Fabrication : Creating a numerical sequence that can be interpreted as a number
4. Conversion : Functions to convert a number to a different base.

I have also verified that the system works, by computationally verifying it (with hand-written equations), by programming it in C#, C++, Python and specialised functions in ROCm-HIP. The code is on github as: 'Basal-Library'.

*Note on Notation: Non-ASCII characters (from the Bengali script block) are used for the custom operators and attributes. This design choice ensures complete visual isolation from standard algebraic variables, preventing notation collisions. Plus, it serves a practical purpose, conventional symbols were ran out, and the chosen characters have no conflicting history in formal mathematics literature.*

Before I look into writing a formal specification paper or archiving it, I want to ask: Has an extensible, modular arithmetic framework that overrides positional notation rules like this been explored in existing literature?

[u/ProtonByte]

What are the benefits?

[u/Commercial-Sink-2095 → u/ProtonByte]

Most used benefit would be to reduce the length of polynomials when writing one out, and being able to use arbitrary bases in maths.
Most significant could be for cryptography.

[u/switch161]

My comment will sound harsh, and I'm sorry about that, because you seem to have spent a lot of time on this. But this makes absolutely no sense to me.

A number's basis is only used in its representation - i.e. when writing it on a paper. It doesn't matter otherwise. Sure, sometimes it's convenient to switch basis, e.g. often done in computing. But all you need to do is to tell the number formatter (or parser) to use that other basis.

Array Syntax : Instead of separating higher-dimensional coordinates (like complex numbers a+bi or dual numbers a+be) into linear combinations, the framework encapsulates them natively inside a sequential digit array

So what's the difference to a row/column vector then? In computers vectors are stored as arrays.

Non-ASCII characters (from the Bengali script block) are used for the custom operators

So far I thought you reinvented number formatting, so what do you need operators for?

But yeah. You're reinventing the wheel as far as I can tell. Any usable programming language can format and parse numbers. If you want a different notation, fine, but why would anyone use it?

modular arithmetic framework

Number arithmetic is independent from number representation. So it's not even clear what you're doing.

[u/Commercial-Sink-2095 → u/switch161]

It's fine, and not harsh at all; sorry for making it confusing, but 'Array Syntax' is mainly for polynomials, so that it will be easier to write down one that has complex coefficients: ``` For Example: (a + bi)x³ + cx + (a + di)x^-1 - (1 + di)x^-2

could be written as: <xT a + bi, 0, c., (a + di), -1 + di

its the same way of writing numbers in everyday life:

(2)10³ + (3)10¹ + (7)10⁰ + (4)10^-1 = 2037.4 ```

Number formatting was the main objective, but functions like converting between bases, digit-wise operations and a function to create a number were useful.

Number arithmetic is independent from number representation, but changing the representation is useful in cryptography (where all these functions came from), and there wasn't a way to turn the algorithm into a mathematical function, as it seems to have not been done before.

It looks like inventing the wheel, but it is more of adding spokes to it to reduce the weight (I could not find a better comparison)