distinguishing scalars, vectors, and matrices as operators or symbols

A Physics derivation has steps and expressions. Expressions are composed of symbols and operations. 

Symbols (e.g., x) can be constant or variable, real or complex. Symbols do not have arguments.

Operations are distinct from symbols because they require one or more symbols to operate upon. For example, +, ^, determinant(), etc.

Within the concept of symbols there are distinct categories: scalar, vector, matrix. The distinction is that they have different properties. A vector has a dimension, a matrix has 2 dimensions. 

Since vectors can contain variables (e.g., \vec{a} = [x,y,z] ) and matrices can contain scalars, then we need a new boolean property for symbols: is_composite, and a new numeric property for symbols: dimensions. 

When "dimension"=0, the symbol is a scalar. Then is_composite is false.
When "dimension"=1, the symbol is a vector. Then is_composite is either false or true. If true then the symbol has two or more edges with other (scalar) symbols.
When "dimension"=2, the symbol is a matrix. Then is_composite is either false or true. If true then the symbol has four or more edges with other (scalar) symbols.

However, this accommodation isn't sufficient. We can say "matrix A = matrix B" and consider the matrices as symbols. However, a quantum operator (e.g., bit flip) is a matrix that operates on a state -- an argument is required. There is an equivalence to the Hamiltonian ("H") and the matrix representation. Therefore the matrix is not a symbol as previously defined.

While the expression "matrix A = matrix B" is valid, " + = + " is not. The difference is that "+" is not a composite symbol.

"H = matrix B" is a valid expression even though "H" is an operator. 

Therefore the distinction between symbol and operators is misleading. The schema for symbols should be

• latex
• name_latex
• description_latex
• requires_arguments (boolean)
• if requires_arguments=true (operator: +, /, ^, determinant), then 
• argument_count (e.g., 1,2,3)
• else requires_arguments=false (variable or constant or operator: a, x, H), then 
• dimension (e.g., 0,1,2)
• if dimension = 0 (aka scalar: "size=1x1" and "is_composite=false") then
• dimension_length
• dimension_time
• dimension_luminosity
• dimension_mass
• if dimension = 1 (aka vector) then
• is_composite = false or true
• orientation is row xor column xor arbitrary
• if row or column, 
• size is arbitrary xor definite
• if definite, "2x1" xor "1x2" xor "3x1" xor "1x3" ...
• if dimension = 2 (aka matrix) then
• is_composite = false or true
• size arbitrary xor definite
• if definite, "2x2" xor "2x3" xor "3x2" xor "3x3" xor ...

That means the major distinct subtypes of symbols are

• symbol that requires arguments
• symbol that does not require arguments, dimension 0
• symbol that does not require arguments, dimension 1
• symbol that does not require arguments, dimension 2