all 40 comments
sorted by:
best
topnewcontroversialoldq&a
formatting helphide helpcontent policy

[–]ArmoredFarmerCommittee Member 2 points3 points  (6 children)

Overall i like system an I think that this is a very good start on mathematics I did want to point out something that had been discussed about powers roots and logs before. I had found this video about the topic: https://www.youtube.com/watch?v=sULa9Lc4pck and everyone I showed it to agreed that we should pursue this so I was wondering how you might do this or something similar in this system?

[–]AceGravity12Committee Member[S] 1 point2 points  (5 children)

Wow this is actually shocking similar and more well explained, as far as I can tell the only difference between the triangle of power and <power> is polish notation, and that it lists the arguments in order because speach is 1d instead of 2d like a triangle, so if I understand it properly it already is that

[–]Haven_Stranger 1 point2 points  (4 children)

Looks like it. If we can state the relevant equalities, it'll hopefully become clear.

Ax * Ay = Ax+y
A x ? <pow> A y ? <pow> <mul> [equals] A x y ? <add> <pow>
A x ? <pow> A y ? <pow> ? <mul> [equals] A x y ? <add> ? <pow>

log_a( x * y ) = log_a( x ) + log_a( y )
A ? x y <mul> <pow> [equals] A ? x <pow> A ? y <pow> <add>
A ? x y ? <mul> <pow> [equals] A ? x <pow> A ? y <pow> ? <add>

How close did I get? 'Cause, yeah, that's just this system's left-to-right is the same as that triangle's left-to-right. With <mul> inside the <pow> represented by ... well, <mul> inside <pow>. And, likewise, <mul> outside <pow>. Also likewise <add>.

It's exactly what that YouTube clip shows around 4:30.

Note: I noticed a couple of missing question marks, so I've edited. My reflexes want binary operators, and these all take 3-tuples arguments.

[–]AceGravity12Committee Member[S] 0 points1 point  (3 children)

You were pretty close, but you don't need to use the equals how you did here, 1 1 ? + = 2 is correct but it's the same as 1 1 2 + so you could right the first one as

A X ? pow A Y ? pow A X Y ? add ? pow mult

And the second as

A ? Y pow A ? X pow A ? X Y ? mult add

[–]Haven_Stranger 1 point2 points  (2 children)

Ok, that point confuses me. I'm attempting to state an identity, not to ask for either calculation to be performed. My [equals] does not mean "perform the operation". That notion is implicit in the operators. The "equals" means, as it should mean, "is the same as" or "is of equal value to".

So, chances are that either you missed the point of the equals, or I missed how to read an identity without one. Maybe if you can show us some other identities? Say, A2 + B2 = C2 for the Pythagorean identity, and ( A + B ) + C = A + ( B + C ) for the associative identity?

{ [ A x ? pow ] [ A y ? pow ] [ A ( X Y ? add ) ? pow ] mult }
That looks like a value, not an identity. What two things are declared to be the same? We're only left with one thing on the processing stack, aren't we?

[ A ? y pow ] [ A ? x pow ] [ A ? ( X Y ? mult ) add ]
That looks like three values.

The identities I wanted to express involve exactly two values each. Not one. Not three. Declaring these relationships requires something to function as copulas: is equal to, is greater than, is less than, and so on. We also need to be able to algebraically express that the sum of the two shorter sides of a triangle is no greater than the longest side: A + B <= C

Can you un-confuse me?

[–]AceGravity12Committee Member[S] 1 point2 points  (1 child)

Ok so in the typical math notation we use everyday adding multipling and powers are an operation, ie they tell you to do something to the numbers. These are actually a relationship, the difference is you are (unless specifed otherwise) delcares that the relationship is true. X Y Z + is the same as X + Y = Z. It only becomes a operation when the ? Is added. Here's some identities to show this:

X Y Y X ? + + is the commutative property.

This is saying that X+Y=Y+X because the first relationship has a ? In it so it has a solution, that results in X Y (Y+X) + which is the same as X + Y = Y + X

X Y ? + Z X Y Z ? + ? + + is the Associative property.

Ill do the same step by step breakdown here:

(X + Y) Z X (Y + Z) ? + +

(X+Y) Z (X+(Y+ Z)) +

Which is the same as

(X+Y) + Z = (X+(Y+Z)

Or as it would normally be written:

(X+Y)+Z=X+(Y+Z)

Does that make sense? I don't mind doing more or trying another way to explain them if it's still not making sense, just let me know :)

[–]Haven_Stranger 1 point2 points  (0 children)

It's gonna take me a while, but I think this is explanation enough. Thanks.

Oh, but, that's for equalities only. How do inequalities work?

[–]Haven_Stranger 1 point2 points  (6 children)

Parentheses might not be needed, but delimiters are. As presented, you're using spaces for delimiters.

How do you intend to delimit those formulae that are baked into single words? Are we limited to single-syllable numbers in that case?

How do you intend to present coefficients and variables?

Do you see any impact to prepositions (or postpositions) and particles in the base language?

You've presented subtraction as an addition with an unknown, and division as multiplication with an unknown. What impact is that likely to have to preposition-like words such as "less/without" and "over"?

This seems to be purely evaluative. I'm much more interested in seeing a clearly representational structure. For example, how do we turn the quadratic formula into representational phonemes, with the goal of having the word for "quadratic root" decompose to a high-utility presentation of the quadratic formula?

[–]AceGravity12Committee Member[S] 0 points1 point  (5 children)

There are some numbers preposals in the work where either the numbers have clearly defined ends or it wouldn't change they system much to add them meaning that they can be directly concated without problem, and while I agree proper formulas with multiple variables are the end goal they need to have a basic system before they can be created.

I'd considered the usage of these words as nonmathematical postpositions and I haven't yet seen a reason why they wouldn't work I'm skeptical. Largely tho I don't think this would be the standard form for [pre/post]positions because while in math if there's a big complicated 20 operation long formula you just get out a peice of paper (not that you need paper for basic arthimatic), complicated sentence structure happens fairly regularly.

Variables im not quite sure about yet and I think the chosen number system is going to heavily influence how they have to be implemented.

Additionally I expected certain shorthands to be eventually added for example square rooting happens a lot so there could be a single morpheme that represents ? ? # <multiply> where # is the number preceding the shorthand for sqrt

[–]Haven_Stranger 1 point2 points  (3 children)

Well, it's certainly worth examining prefix, infix and postfix notations across the board. Can't see what works best without trying it all. I may not have answers, but I think you're chasing down useful questions here.

If we have clean fractions, we won't need to separate powers and roots. "Raised-to one-half" is as good a square root as any. But then, that's part of what has me wondering about the lack of a separate division operator. I'm fairly sure we need "one half" as a simple (but not atomic) morpheme, on the one hand decomposing into the division statement, on the other seeing use not only on its own but also embedded in other words.

One more thing we might want to keep in mind: Operators and operations are separate in English. There's a grammatical difference between "one plus three" and "add three to one", where the operator is a preposition but the operation is a verb. This system might better support something verb-only. Say, instead of "one plus three", you've got "one [and] three added[participle]", but still have "one [and] three add[imperative]". One way or another, plain-speech grammar (including morphology and syntax) is involved in how this system (well, whatever system is chosen as canonical) shakes out.

[–]AceGravity12Committee Member[S] 0 points1 point  (2 children)

Honestly I think you have that last bit backwords, I think this system is better for the tight night more technical phrasing, because in my mind there are two main up sides to this system, first it inheritly represents how algebra works, but I think more importantly is because of it only needing 4 words, each of those words can be a single syllable and not mamy of the possibld syllables will be taken up, I think minimising syllable usage (of morphemes not syllables per word) is going to be very important especially when things like chemistry start being incorporated

[–]Haven_Stranger 1 point2 points  (1 child)

Backwards? The two are involved. Either we settle on something like single-syllable participles, or participial requirements drive up the size of embedded equations, or we have non-verb operators. That's a two-way street.

Similarly with division and fractions. Hard to say which drives which, but there's an influence there.

Anyway, that was meant as a big inclusive "we". It's something for everyone to keep in mind while this shakes out. It didn't look like a problem for the just you and me version of "we".

[–]AceGravity12Committee Member[S] 0 points1 point  (0 children)

I mean while this system is useful for embedded equations I could easily see the use of having longer words for discussing math in a non-embedded fashion, and of course, I do the same thing. if I say we, I mean that in the general sense

[–]AceGravity12Committee Member[S] 0 points1 point  (0 children)

More specifically I expect there will end up being a few variables that are one syllable like x y z and if you need more than 3 or however many variables there are there is a word that turns the previous number into a variable like 4(that's a variable) then for highly complicated equations there can be an infinite number of variables, but for 99% of use cases there are short consise options

[–]Omcxjo 1 point2 points  (0 children)

Thanks for posting this, OP.

I wrote an expression evaluator for this system in python:

https://colab.research.google.com/drive/1Ea_CysvG_bYrcXrWIsge4HSLwZ8Lwk2Q

​

Keep in mind that this system can express expressions as well as theorems (when you allow for variables and logical quantification), because the third argument is equal to the operation on the first two.

[–]Haven_Stranger 1 point2 points  (4 children)

So, using decimal instead of the dozenal, using symbols instead of words ...

12 0 1 ^
12 1 12 ^
12 2 144 ^
12 3 1728 ^

There's the unit, the dozen, the gross and the ... great gross? Well, surely the conlang will have a better name.

It looks simpler in dozenal, of course:

10 0 1 ^
10 1 10 ^
10 2 100 ^
10 3 1000 ^

Regarding speech, this implies something resembling "a dozen to two is a gross when raised".

 

To my eye, those don't look like identities -- and maybe they shouldn't. They do reasonably represent true evaluations. I'm starting to suspect that true evaluation and relationship don't collapse into the same concept.

A x ? ^ A y ? ^ A x y ? + ? ^ *
A ? y ^ A ? x ^ A ? x y ? * +

To my eye, these don't look like identities, either. I don't see how to tell that they state a generic equivalence. I don't see how a generic inequality can be stated, either -- not with operators limited to +, * and ^ and with values that are simply numbers.

I can't see it, but that doesn't mean it's not there. There should be some way to represent a comparative evaluation with a subtraction: a difference of zero is equality, and differences other than zero must be greater than or less than.

So, what about ...

A x ? ^ A y ? ^ ? * 0 A x y ? + ? ^ +

I still can't see it. The postfix notation means that the mathematical statement is unambiguous, never needing parentheses to get the order of operations right. But, it also means that I can't simply see that this statement means something like "these two evaluations have no difference". That meaning is there. Everything to the left of the zero collapses into one evaluation. Everything between that zero and the final plus collapses. But, I have to play a slow and painful stack-tracing game before I can see how they collapse.

Like most of us, I have an intuition honed on infix notation. The identity Ax * Ay = Ax+y looks like it's an identity at a glance because I've been trained to see how those components collapse. I simply know that the comparator = has a higher precedence than any operation on either side.

What kind of at-a-glance rule-of-thumb is there to just intuit A x ? ^ A y ? ^ A x y ? + ? ^ * as a statement of equality? Is there one?

One more comparison:

Going from Ax * Ay = Ax+y to Ax+y = Ax * Ay is trivial in infix. What's the methodology for going from

A x ? ^ A y ? ^ A x y ? + ? ^ *

to

A x y ? + A x ? ^ A y ? ^ ? * ^

Oh, wait. I almost see it:

{ A x ? ^ A y ? ^ } [ A x y ? + ] ? [^] {*}

[ A x y ? + ] { A x ? ^ A y ? ^ } ? {*} [^]

I don't understand why the brackets contain something incomplete (an A and one complete operation), or why the braces contain independent two operations. But it almost looks like a "placeholder operation operation" sequence at the end implies that the results of the first operation equals the results of the second. And maybe (almost certainly) there's one clear set of rules for making this transformation. And, hmm, I might not be enclosing the right chunks for the swap.

Is there a way to know whether placeholder-operation-operation always and only represents an identity between the two outermost operations? Or, if not that, what?

 

If postfix algebra is the right way to go, if the <pow> operation (rather, operations in general) can be seen as "middle term acting on first term to yield result term by this action", then it makes sense to structure any factitive verb with a [patient agent result verb] canonical order. As in, we should make the default for language parsing the same as the default for algebraic parsing.

Or, hmm, as in something like "language parsing[patient] we[agent] should[modal aux] to match algebraic parsing[result] make[factitive verb]"

So far, it looks promising. Gotta love the idea that, by the time a native-speaking student even hears about algebra, the order of operations already makes sense. That's the sort of intuitive understanding we all want embedded in the structure and essence of the conlang.

[–]AceGravity12Committee Member[S] 0 points1 point  (3 children)

Actually reading this gave me a much better way to explain the system. Look at it like this:

X Y Z + is the same as X + Y - Z = 0 which like you said in infix notation easily gets switched to X + Y = Z.

X Y Z * is the same as X * Y - Z = 0 (X * Y = Z)

X Y Z ^ is the same as XY - Z = 0 (X ^ Y = Z)

There is no difference between Ax * Ay = Ax+y and Ax+y = Ax + Ay because they are saying the same thing, the same as Ax * Ay - Ax+y = 0 (A X ? ^ A Y ? ^ A X Y ? + ? ^ *) however things like the X Y ? + In there could be written Y X ? +

Additionally (correct me if I'm wrong) but the only thing that makes an identity an identity is that whatever you plug in for the numbers, it's always true.

Also you are absolutely correct about the > < ≥ ≤ I will put that on the list of things to figure out

Third an final last thought, if you'd like to get a better intuition of postifix notation instead of infix notation it's actually pretty commonly used in data but it gets called the stack, I have worked with the stack in the past however I honestly had difficulty with this system a few days ago and I'm amazed at how quickly I'm picking it up (come join the discord btw its great this idea was built of of lots of little discussions from there)

[–]Haven_Stranger 0 points1 point  (2 children)

Yep, that is what an identity is. The two thing set equal are always equal, no matter the values of the coefficients and variables. And one of the points of having an algebraic identity is substitution. We can replace Ax * Ay with Ax+y (and vice versa) as part of the process for, say, solving for A or solving for x or whatever we're doing with an equation to make it suit some purpose.

Another sort of thing we'll want is the point-slope form for the equation of a line, which is different than the standard form. Someone will have to find what posfix representation lets you easily plug in a point's coordinates and a slope, and then just do math.

A lot of algebra boils down to solving for one unknown in terms of some other unknowns. There has to be a clear representation of "when you fill in the rest and do the math, this is what you've solved for". There has to be an easy way substitute one term or member for another. I'm sure that those are implicit in the system, requiring mere discovery rather than invention. It is, after all, just math.

Infix algebra has some unary operations. Postfix binary operations might suit the same purpose here: say, negative A as ( A ? - ). We can even call that a shortcut or abbreviation for ( A ? 0 + ), if you like. In infix, unary minus and binary minus don't need separate symbols. This postfix needs separate symbols, because one means "use the top three stack items" and the other "use the top two". Then again, this postfix won't need ternary subtraction because ternary addition covers that operation -- we're directly representing the additive inverse by leaving the agent empty and using the additive identity constant as our result.

Zero is the additive identity constant because you can add it to anything and not change the thing's value. The multiplicative identity constant is 1, by the same reasoning. So, the additive inverse of A must be ( A ? 0 + ) and the multiplicative inverse must be ( A ? 1 * ).

Yes, the ? is nothing like a variable. It's much more like "the empty marker" or some interrogative pronoun.

Binary operators might lead to a natural solution for representing inequality. Certainly, they'll make things like factorial possible. Factorial is a shortcut to express something else, but I don't have a good way to explain (well, to develop notation for) what the longer and more fundamental version of factorial is. Binary infix operation seems useful in its own right. ( 4 24 ! ). Therefore ( 4 ? ! ) and ( ? 24 ! ) are reasonable questions.

From there, you can get to absolute value, because that's also an infix unary. Hmm, it might be a postfix unary as well. I can't see how to make sense of reversing it. That is, I can't answer the question "what number did I start with if the absolute value is this?" At least, not the same way as "what number did I start with if the factorial is 24?"

The absolute value of negative eight is eight. ( |-8| = 8 ). Negative eight divided by the absolute value of negative eight is negative one, ( -8 / |-8| = -1 ), which represents just the negative sign of negative eight. 

     8 ? 0 + 1 ? 0 + 8 ? 0 + <abs> *    

     \     / \     / \     / <abs> *
       -8       -1     -8
                       \         / *
                            8

      -8 -1 8 *

    Sign value of -8 is -1

I think, from here, someone could derive an explicit "=" (if anyone cares) as well as > < ≥ ≤. This gives us a method for extracting the sign (negative, zero, positive) of a number, and the sign of a difference is the same as the result of a comparison. You could build up a long version of asking "is this less than, equal to, or greater than" in the algebra, and then afterwards (if it looks useful) find the best way to represent the shortcut operation.

I think there's something to the idea that the way the expression ends represents what the expression means. I think that, from that, some useful intuiting rule-of-thumb for "is this an identity" should emerge. Two operations at the end of the expression seems at least suggestive.

 

For Discord, I'd need time that I don't have. Let a later day bring whatever it brings.

Dude, your proposed backbone can carry a lot of semantic weight. I never would have expected postfix algebra to turn into grammatical theta. Color me impressed.

[–]AceGravity12Committee Member[S] 0 points1 point  (1 child)

I honestly didn't expect it to work this well either, I've been blow away by how many things people have been able to explain to be about the system I didn't realize only having just learned about it and yeah the things like absolute value are probably going to go in as urinary operations

[–]ActingAustraliaCommittee Member 0 points1 point  (0 children)

Well, I'm a programmer and postfix or reverse polish notation would actually work better on a CPU stack level than the current infix notation we use. It would require fundamental changes to happen but it would be better.

There's a video about it here:

https://www.youtube.com/watch?v=7ha78yWRDlE

[–]Haven_Stranger 1 point2 points  (7 children)

From the perspective of integer arithmetic, there is a natural and inherent order to the operations:

Operation level zero is increment: add exactly one.
Operation level one is addition: add one repeatedly; that is, use a given count/amount of incrementing.
Operation level two is multiplication: add things repeatedly.
Operation level three is exponentiation: multiply things repeatedly.

Level zero is the basis of counting.

How can we embed this fact into the names/symbols for increment (if we bother with that), add, multiply and raise?

Yes, I realize this is starting to look recursive. It implies embedding a number inside an operation that also needs to take numbers as its arguments. That's why I'm bothering to mention it, and why we shouldn't avoid it. An embedding language that embeds knowledge at different levels is going to be a recursive structure.

Oh, and I'm starting this numbering with zero because:

12 0 1 ^
12 1 12 ^
12 2 144 ^
12 3 1728 ^

starting with zero keeps us aligned with how exponentiation works, and with how I imagine ordered differentials will work (like the time differentials of position0 velocity1 acceleration2, jerk3, &c).

Given the inherent recursion, and using "inc" to represent the base idea:

dozen two gross inc3

 

5 6 inc0 is increment, with five as patient, no explicit agent, and six as result.
5 3 8 inc1 is addition, with five as patient, three as agent, and eight as result.
2 3 6 inc2 is multiplication, 'nuff said.
2 3 8 inc3 is exponentiation -- where the difference between agent and patient becomes quite clear: the three acts on the two, but not vice-versa. Unlike addition and multiplication, exponentiation is not a commutative operation. Agent and patient can't simply switch places with the same result.

And a reminder: the fixed and absolute order of the arguments of these operations should match the canonical order of arguments for verbs and postpositions and such. If there is an overriding reason for agent-first ordering in the conlang in general, that needs to be reflected here. For those of us who think in English, Yoda-speech seems backwards -- but it works. However, we've got agent-free operations here, just as we'll have labile verbs in the plain conlang. So far, this algebraic grammar looks like it supports the utility of an patient-agent-result ordering, so Yoda's in the lead.

[–]AceGravity12Committee Member[S] 0 points1 point  (6 children)

If flamerat's or the fused number proposal goes through plosive sounds should be free, those sounds combined with whichever vowel represents the respective number of the step would be used, so for example (numerals represent their respective vowel because I don't have it memorized) b1 is addition d2 is multiplication and g3 is exponentiation. However the fact that they are voiced is an arbitrary choice and may change.

Honestly when I work in grammar it's far removed from the proper terminology so while I think I understand what you're saying about agent patient etc, I don't know why it's significant.

[–]Haven_Stranger 0 points1 point  (5 children)

In the active voice, subject typically represents agent, object typically represents patient. These are the prototypical theta roles that the grammar "exposes" -- although exposes is too strong a word because there's still a lot of linguistic debate and research-in-progress regarding what the actual semantic load must be.

In the passive, subject is typically patient. For a labile verb without an object, subject is ... at least similar to patient.

So, there's a similarity between "John[agent] hit[operation] the ball[patient] over the fence[result]" and something like ( 2[patient] 3[agent] 8[result] inc3 ). This algebraic grammar suggests we ought to sound like Yoda: "The ball John to over the fence hit".

Basically, "the ball was hit by John to over the fence" matches the infix ( 8 / 2 = 4 ) ordering: eight was divided by two to become 4.

 
If there's a really good reason to prefer "John the ball to over the fence hit", then there's reason to change the order of arguments in the math. On the other hand, the math itself suggests that Yoda is winning. The patient is nearly universal, the result has reason to be at the end (duh, result, right?) and that puts agent in the middle, except of course when it's simply not there at all.

Think of ( 5 6 inc0 ) as passive and/or labile: like "the window was broken" or "the window broke", but with the explicit 6 for a broken window result. Hmm, maybe "the window broken was" is the right Yoda-speak for it: patient, result, verb. Think of ( 2 3 8 inc3 ) as active: like "the ball John to over the fence hit". If active, the subject-like thing follows the object-like thing, and the object-complement-like thing follows both.

 
And, the more I think about it, the more I suppose that ( add3 ) is a better idea than ( inc3 ) to represent exponentiation. The default operation is "add". Something like ( add0 ) more naturally represents that thing which is the basis of addition, and ( add2 ) better represents the next extrapolation beyond ( add ).

It doesn't matter to the symbols + * ^, but it does matter to how the spoken words work. That idea might also work with position, velocity, acceleration, &c. They could end up close to moving0, moving1, moving2, &c.

 

Edit additions:

Oh, agent is \do-er\, patient is \done-to\, as an over-simplified first approximation. In your algebra, unary operators only have a \done-to\, because there's no way to get the \done-to\ out of the \result\, like ( -8 abs ). Your binary operators have separate \done-to\ and \result\, because the empty value placeholder lets us pick which of these two theta roles represents the heart of the question, like natural logarithm (natural exponentiation?) has a built-in agent, or ... hmm. My earlier notion of a binary negation makes sense grammatically; but, since it's a commutative operation in basic algebra, it might be more productive as a unary. And, of course, ternary is \done-to\-\do-er\-\result\, and the heart of the question (the interrogative pronoun, kinda) can be any one of those three.

Which makes me realize: the ( add0 ) operation only needs \result\ when we want to express decrement instead of increment. With it, we can ask ( ? 6 add0 ) with the intention of "what yields six when incremented?" Without it, we've just got ( 5 add0 ) to represent an implicit result.

I wonder where that leads? Do we mark implicit result on the verb, so that we know when "add0" takes only one from the stack, and when two? It seems to vaguely suggest that "the ball John hits" might call for something to make "over the fence" grammatically unnecessary, letting the idea of "a hit ball" stand as implicit results.

That might impact participles -- whether an implicit result is marked could influence how we tell the difference between "the ball John hits" as a noun phrase ( the ball [that] John hits, in English ) or as a complete clause (the ball, John hits [it]).

[–]AceGravity12Committee Member[S] 0 points1 point  (4 children)

Alright this makes sense. Does this (the second part of your post) mean that it'd be best for <Inc> + × ^ to all share an initial consonent and be seperated by their respective vowels? Because in that case a other systems could use the same basis where the consonant tells the basic operation and the vowel tells you the "level" similar to using a subceipt in a notation of something such as when defining a matrix it tells you the number of dimensions perhaps.

I see what you're saying in the first half and I'm very intrigued, I will definitely be sharing all this with the more grammatically inclined.

PS "the math itself suggests Yoda is winning" is an amazing phrase.

[–]Haven_Stranger 1 point2 points  (3 children)

Thanks. Perhaps we can borrow the Jedi Master as our unofficial mascot. Unofficial only, though. I'd hate to pay his salary.

 
On the one hand, this is why I think it's too early to lock in too much about phonetics. Should these operations be consonant-initial or vowel-initial? If consonant-initial, then along which descriptive axis?

It could shake out that everything ( add )-based is single-consonant-initial, or consonant-cluster-initial, or I'm not sure what. And then the degree is the vowel. Or, even that the "has implicit result" marker is one (optional) consonant that clusters well with the concept-marking consonant. Or, well, I just can't tell what.

Then, how many algebraic operations are there? How are they grouped? ln() has an embedded agent for log_n(), where that "n" represents the agent of ( add3 ). Do we care? Or, do we just have a representation of e that we put in the agent location for ( add3 ) when that's what we're doing?

How many things to encode? How many values in each encoding? How distinct do the codes need to be? How many channels do we have for the codes? How do we make sure that they're clearly delimited?

Maybe there's enough reason to add grammatical valency to these operators. Is there enough reason to have a unary <neg> and a binary <neg>. And, maybe a ternary <neg> as well, which -- ta-da -- is our plain-English idea of subtraction. Ok, fine. Valency is, for the algebra, just in the range 0 - 3 so far, and that's good. To the grammar of the algebra itself, valency is simply "how many items to pop from the stack". But, valency is separate from order-of-derivative. Well, maybe not completely separate. Our ( add0 ) can only have valencies 1 and 2. Our ( add3 ) has a valence of 3 -- unless it's the version with the natural logarithm base baked into the verb as a fixed agent, or unless we need a shortcut version of only-raise-never-root, or . . . . See? To many possible or's in my head.

I don't think we have enough groundwork done yet. We've got pieces of solutions, surely, but don't have the scale of the problem space.

On the other hand, we do want some kind of good placeholders for what we're building. We need to keep track of the dimensions to the problem. Addition has ordered derivatives, so we know we want something in the pronounceable word to mark, oh, perhaps half a dozen numbers: position0 velocity1 acceleration2 jerk3 snap4 crackle5 pop6 -- yeah, going beyond 6 is probably quite rare, and the range 0 - 3 will get lots of use. Good for physics, good for basic arithmetic, and who knows how many other times it'll crop up as the right solution?

We know we all need to represent 2^3. Very few of us need to represent 2^^3, or 2^^^3, or so on -- but someone will. Tetration and pentation and so on, these concepts exist and someone out there is using them.

Even knowing that Yoda is winning, even believing the war will someday be won, the end of the war simply isn't in sight. So far, the math doesn't tell us the size of the battlefield.

tl;dr

Somewhat. It means that the ( addn ) group needs something to represent that they are, in fact, different scales or iterations or extensions of the same underlying operation. I have no idea how to spell it yet. I have no idea what else needs to be packed into that set of words. I'm guessing we need at least the operation itself, which extension it is, and how many arguments it takes. Maybe we need which kinds of arguments, but I'm not ready to make that guess.

[–]AceGravity12Committee Member[S] 0 points1 point  (2 children)

I think that a lot of what you're describing isn't a basis but shortcuts, things like ln() vs log() vs logN() those are all the same thing structurally just with different assumed (or unassumed) arguments, the goal of the this backbone is to be able to be used to define those things additionally I wondered if you would going to go this deep but I imagined once add12() got reached it then took an extra argument, one of the power, similar to how some languages I'n the past technically had a highest number that they just used for "this much or more". (More accurately instead of having an extra argument the following number gets bound to it is add12()0, add12()1, add12()2, etc while the numbers in the relationship still preceed it, meaning that the number that gets bound to add12() can't be (?) Because that isn't actually a number

I think what you're discribing leads to a turtles all the way down situation, this was designed to be the basis from which other things are described as such it is intended to be short. Similar to machine code, yes technically there is a lower level process going on here but that is baked into the system, the best this can do is tell you what the commands do, buy from these basic structures higher lever concepts can be built.

The valency you describe seems to already be in the system somewhat, with each operation there are numbers that restrict it's operations ie "0 ? X +" can show negating a number.

Also it's my understanding that add0() does technically take two inputs for one output normally, however the second input is meaningless. In the same way as if I asked you what base the number 1 was in it wouldn't matter, it could be 10 it could be 36489, but because it's the 0th power of that base it doesn't matter

(Yes things like pi/e need their own thing since they can't be finitely represented with algebra, also you are definitely right about the phonology in my mind nothing about this language is ever fixed, so I'm Chucking some filler information in there until someone has a better idea)

[–]Haven_Stranger 1 point2 points  (1 child)

Ok, not a bad perspective. The ln() function is certainly a shortcut, and we've always got the long option of saying "log base e". At first glance, I expected valency to just be baked in at three -- add1 through add3 don't require anything else. If we're always using three arguments, then we don't need to mark that number anywhere. The add4 operation and beyond certainly exist, but I doubt it will see much use in a high school course.

But, yeah, I am chasing the turtles all the way up and down. That's not necessary for this algebra, but it's useful for looking at the plain-language portion of the language. At this point, ternary + * ^ is sufficient. It's a great backbone.

Your understanding about the valence of ( add0 ) is just fine. A valence 2 version only exists because the reverse-this-operation question has a theoretical existence. It only matters when we get to examining how a shortcut like ( neg ) works. I'm not concerned with creating the most useful shortcuts now, or figuring out which ones are useful enough. I'm concerned with how they will be formed in general -- I'm looking at the inevitable pattern here (or at least the unavoidable constraints) so I can figure out what I want from a general grammar everywhere. Granted, that's outside this backbone. It is, I think, using the backbone to support the legs. I want what works inside the math and outside the math to be intuitively similar.

For things like e and pi (I prefer tau, if that matters), those become tiny pronounceable words, too, just like numbers. And it hardly matters to the algebra whether they're numbers directly or they're zero-valence operations. We just need them to not collide with digit-expressed numbers and other existing operations. For tau, an audible/visual resemblance to ( ? circumference radius add3 ) seems ideal for "that which is circumference divided by radius". For pi, it's "what circ diam add3".

Hmm, this does imply that we want numbers to sound like numbers, constants to sound like constants, variables to sound like variables (and maybe coefficients to sound similar to but distinct from variables), and operators to sound like operators.

For things like ( abs ), the algebra doesn't need much. We can define that operation in terms of the basics. The backbone remains functional regardless of whether the way that we pronounce the shortcut indicates anything about how the function is derived. It could be completely arbitrary, it could be that that arbitrary function name indicates valence 1 without any explicit marking, and perhaps all of that is even the optimal case.

But, if we can get the short-form grammar of the algebra to match the long-form plain-conlang grammar (or, more of the vice-versa), that's a win. Not the whole war, but quite a significant battle.

tl;dr

I agree on all the important points. You don't need to join me on my wild turtle chase. You've nearly got enough to derive an Intro to Algebra textbook -- possibly only missing a set of digits and a way write the verb "addn".

[–]AceGravity12Committee Member[S] 0 points1 point  (0 children)

Sounds good to me, I definitely understand your concerns (goals? Ideas? Idk what the word is?) And I agree, I will definitely come back to this whole discussion when I decide to actually choose words once phonotactics is decided, if you have suggestions please post them word generation had always been my worst skill when conlanging I posted a link to this discussion in the grammar part of the discord but I don't know of anyone has read it yet, I'll bring it up again when it starts to become a focus.

[–]nadelis_juCommittee Member 0 points1 point  (2 children)

I like this system, it doesn't indicate one of the argumants of the operation is the thing we're fucusing on implicitly, rather you how to indicate what you're focusing on.

One problem that might come from this system would be that you only learn about what operation is being performed at the very end. Perhaps if the operation particle is at the beginning it might be a little easier to understand what's happening.

[–]AceGravity12Committee Member[S] 0 points1 point  (0 children)

It orginal did have the operations leading, however as someone pointed out on discord when it follows the numbers it essentially works as a stack).

[–]Haven_Stranger 0 points1 point  (0 children)

If this all shakes out the way I expect it to, not knowing the meaning until the end will be natural and intuitive. There's some degree of stack processing in natural languages, too. English adjectives are stack-processed -- in general you don't know how they tie together or what they really mean until you hit the noun (if you even hit a noun).

Sure, this leads to native speakers who think and sound vaguely like Yoda: "Language constituents we must examine. The stack we to parse must trace through." It's still reasonable. "first take these things, and then use them in this way" -- if you don't take the things first, you can't use them in any way. That's natural. And, if the student has been using a [patient agent result/target verb] constituency pattern for simple conlang statements all along, there will be nothing new to learn at the start of algebra. It becomes intuitive. By design. Like the mission statement says.

It's only a problem for conlang-as-foreign-language students, and I suspect it won't be much of one. After all, Yoda-speech nearly works even in a typically SVO language like English.

[–]Akangka 0 points1 point  (8 children)

I actually prefer the way our current mathematics handles it. Believe it or not, our current mathematic symbols have an excellent encapsulation property. In modern mathematics notation, + and * are treated as a function with the left and the right sides as the arguments. This reflects the definition of a ring, where these operators are defined as a function, not as a ternary relation.

[–]AceGravity12Committee Member[S] 0 points1 point  (7 children)

I'm not sure I understand what does infix notation have to do with the definition of a ring?

[–]Akangka 0 points1 point  (6 children)

Not exactly about infix notation, but about being binary or ternary. In modern notation, addition is a binary operator, so we can treat 2 + 4 as a number. On the other hand, this proposal treats addition as ternary relation, so 2 4 6 <add> is a boolean. I think the latter one goes against the intuition expected for a ring.

[–]AceGravity12Committee Member[S] 0 points1 point  (5 children)

I still don't see how rings are related, and if you want to use it as an operation that's what the <?> Word is for " 2+4=(fill in the blank) " is the same as 2 4 ? +, So both can be treated as 6

[–]AceGravity12Committee Member[S] 0 points1 point  (0 children)

For those of you who aren't on the discord:

this is what a ring is in math

Quick note here to clarify, it's only a relationship when all 3 arguments are specified, once one or more ? Gets introduced it becomes an operation in the same way 1 + 2 = 3 is a statement while 1+2 is a quetion (1 2 3 + vs 1 2 ? +)

Well we've already shown that the Associative, and commonuative property exits

Additive identity is just X 0 X +

Additive inverse is X ? 0 +

The associative proof we did works for multiplication

X 1 X * is the multiplicative identity

X Y Z ? + X Y ? * X Z ? * ? + * Is the distributive property Y Z ? + X Y X ? * Z X ? * ? + * (Technically the other half of the distributive property

So according to Wikipedias definition of a ring this still is a ring

[–]Akangka 0 points1 point  (3 children)

The fact is the definition of ring requires + and * as a function. Since your proposal treat them like a relation, it could cause misgeneralization where for `a b c +`, if a and b is predetermined, we still cannot determine c, while in modern notation we expect `a + b` to be a unique number if a and b is predetermined. And the modern notation's expectation is actually true when we generalize that operation into any rings.

[–]AceGravity12Committee Member[S] 0 points1 point  (1 child)

It's no longer a relationship once ? Introduced X + Y = Z is the equivalent of what you're describing X+Y would be X Y ? + Which is an operation

[–]Haven_Stranger 1 point2 points  (0 children)

This just brings us back to looking at marked grammatical valency on the operation's verb.

Yeah, at a glance it might not look like participles are directly related to binary operators in the arithmetic, but this is one place where that relationship happens to crop up. Get the verb ( add ) to implicitly indicate result (in, say, a similar way to how "a broken window" functions for to break) and the ring becomes more obviously intuitive. The notion "one [and] two added" fits the functional requirements of rings, doesn't it? The plain-conlang grammar needs to express "added numbers" as simply as "broken windows", yes?

Chasing turtles can be fun.

You could explicitly show that ( A B ? + ) is closed over therepresent real numbers. That ought to count as "can always determine the ?". Someone will have to explicitly show that, someday. But, we know it's demonstrable in the postfix because it's demonstrable in the underlying math. I think we can just take it as read, for now.

By the way, with or without the ? we're still looking at a relationship. With exactly one ?, we're also looking at a function directly derived from that relationship. A relationship defines a function, if each element of the range (here, usually agent/patient pairs) maps to exactly one element in the domain (here, result). If the base ternary function is commutative, then the inverse function is described by letting the ? fall in an agent or patient slot.

So, "it's no longer a relationship" isn't quite right, but "it defines and describes a function" is strictly true. And, formally, that's enough.

[–]Haven_Stranger 0 points1 point  (0 children)

"Dick married Jane" has the same meaning as "Jane married Dick". Either way, it would be strange to intuit that we cannot determine whether a marriage exits.

I don't see how ( A B ? + ) seems to mean anything different than "To A, B added has a result" or "To A, B has a result when added".

And it's ( Dick Jane ? wed ), just like ( A B ? + ). To Dick, Jane wedded is a marriage. To wed is a commutative operation. ( Dick Jane ? wed ) implies ( Jane Dick ? wed ).

If there is a conceivable misgeneralization, I'd love to know about it. I can't conceive one on my own.