Is there a standard symbolism for relation of "equality without transitivity" (like assignment, to a variable or set; respectively xRy or xRY)?

Question

Many software languages use "=" for assignment and "==" for mathematical equality, but how mathematically can the former be conveyed (roughly meaning "corresponds to, but ostensibly not equivalent to")?

A related question: Is there a way to express membership (of some broader category) without denoting the child object as being one of xeither an element or a subset (e.g. ∋ vs. [⊋,⊃,⊇] child) orand that the parent object is generically one of xeither a set or subset (e.g. ∈ vs. [⊊,⊂,⊆] parent)? An analogy of the former is "(noun x) is a (thing of property y)" or "(noun x) has (characteristic Y, or is adjective descriptor y)" where Y:={all y}" but where the predicate in either case is ambiguous (i.e.; could be an arbitrary element of some class, or some set defined within a group), and latter being approximately "(some thing(s) of property x is(are)) is (proper noun y)" or "(property X entails (things defined by y)" where in the first case the "closest-defined parent group" of the antecedent does not necessarily wholly contains the "closest-defined parent group" of the predicate but the latter does.

A question related to the preceding paragraph: Is there an explicitly ambiguous subset/superset symbol to denote "might or might not be equal to"? Or is the best simply the version without the underline?

Less specific to the topic: Is there a big list of mathematical TeX-based symbols that don't have current Unicode counterparts, preferably accompanied by proposed meanings or example usage and closest-Unicode counterpart? Some of the ones in this post I copied from block U+22Fx at https://en.wikipedia.org/wiki/Ordered_set_operators. Also what does four-bar and over-line/over-line ounterparts of element-of\contains symbols (e.g. ⋹, ⋸) mean? overbar for complement of, under for "or equal to"?

Answer 1

Answers to each paragraph:

• It depends what exactly you think "assignment" means, but as in pseudocode, the symbol $\leftarrow$ is often used to mean "a variable is given this value".
• I don't understand the second question. Membership is always $\in$, including if the larger thing is not a set (e.g. if it's a class or category). If you want to say "$x$ has property $y$" then say it in words, or let $Y$ be the collection of all things with property $y$ and say $x\in Y$. In logic, if $y$ is a formula you would sometimes say $x\models y$ ("$x$ models/entails $y$").
• $x\subseteq y$ means "$x$ is a subset of $y$", which is true if $x=y$. (The term for a subset which is not equal to the whole thing is a proper subset.)
• This seems off-topic for math.se. There's a TeX StackExchange. I'm not familiar with the two symbols you list and so I would guess that there is no universal standard definition of their meaning, but that authors might use them if they're defining a shorthand or a new idea which resembles membership in some way but needs to be distinguished from it (e.g. "say that $x$ is a member of $y$ with respect to the function $f$ iff $f(x)\in f(y)$".)

Answer 2

Regarding paragraph two, lots of students misuse the equals sign here. You might see “Let $G = \text{group}$” as shorthand for “Let $G$ be a group.”

It could be fixed to “Let $G \in \operatorname{ob}(\mathbf{Grp})$”; that is, $G$ is an element of the class of objects in the category of groups. But that's not any clearer or quicker to write than than “Let $G$ be a group,” is it? If English words suffice, use them.

Answer 3

The assignment operator one finds in computer programming is not reflexive, symmetric, or transitive, and it's a category error to even ask whether it is, because those are properties of relations, and the assignment operator is not a relation.

A relation, in mathematics, compares two values and tells you that they are, or are not, related in a certain way. The assignment operator, however, does not compare anything, and does not tell you anything. It is a command to perform a certain action.

In a typical programming language, the expressions on the left and right of the assignment operator are entirely different things:

• The right side is a value
• The left side is a reference to a memory location

To help understand the difference, consider these programming language utterances:

    x = 4        // straightforward

versus

    4 = x        // nonsense

(By way of example, the C language mandates that the compiler must reject 4 = x and issue a fatal error message.)

Similarly consider:

    x = y + z        // straightforward

versus

    y + z = x        // nonsense

In x = y + z, the values stored in locations y and z are looked up; these values are added, and the sum is stored into the location x. The x need not denote a value, and even if it does, the value is not looked up, because it is irrelevant. Rather, x is mentioned because it denotes a place where the value of y + z can be stored.

In a typical programming language, the right-hand expression is evaluated, to produce a value, but the left-hand expression is not evaluated, and instead is required to have a special form that can be understood to denote a specific location in the computer's memory. The right-side value is then stored at that location. Nearly every language that supports any sort of assignment makes the same distinction. Mathematics does not usually deal with anything like locations in a computer's memory, so doesn't usually have anything like an assignment operator. Assignment belongs to computer engineering, not to mathematics.

In languages that keep track of data types more carefully, the asymmetry is apparent in the types. For example, in Standard ML, there is an assignment operator :=. Its right-side argument can have any type α, but its left-side argument is more limited: it must have type ref α, which is SML's way of saying that it must be a special sort of thing that can be assigned a value of type α. The complete type of the := operator is (ref α) * α -> unit, which means that it takes the reference, and the value, and returns a meaningless dummy result (unit). In contrast, the type of any of SML's relational operators is the symmetric and much simpler α * α -> bool, which means that it takes two values, both of type α, and gives back a boolean (true or false) result that says whether the two values are related.