# Tex SytmbolsΒΆ

      // A

bin := "\amalg"                 // $$\amalg$$
cmp := "\approx"                // $$\approx$$
cmp := "\approxeq"              // $$\approxeq$$
cmp := "\Arrowvert"             // $$\Arrowvert$$
cmp := "\arrowvert"             // $$\arrowvert$$
cmp := "\asymp"                 // $$\asymp$$

// B

cmp := "\backsim"               // $$\backsim$$
cmp := "\backsimeq"             // $$\backsimeq$$
cmp := "\bar"                   // $$\bar$$
cmp := "\barwedge"              // $$\barwedge$$
cmp := "\between"               // $$\between$$
bin := "\bigcap"                // $$\bigcap$$
bin := "\bigcirc"               // $$\bigcirc$$
bin := "\bigcup"                // $$\bigcup$$
bin := "\bigodot"               // $$\bigodot$$
bin := "\bigoplus"              // $$\bigoplus$$
bin := "\bigotimes"             // $$\bigotimes$$
bin := "\bigsqcup"              // $$\bigsqcup$$
bin := "\bigtriangledown"       // $$\bigtriangledown$$
bin := "\bigtriangleup"         // $$\bigtriangleup$$
bin := "\biguplus"              // $$\biguplus$$
bin := "\bigvee"                // $$\bigvee$$
bin := "\bigwedge"              // $$\bigwedge$$
bin := "\bowtie"                // $$\bowtie$$
bin := "\Box"                   // $$\Box$$
bin := "\boxdot"                // $$\boxdot$$
bin := "\boxminus"              // $$\boxminus$$
bin := "\boxplus"               // $$\boxplus$$
bin := "\boxtimes"              // $$\boxtimes$$
cmp := "\Bumpeq"                // $$\Bumpeq$$
cmp := "\bumpeq"                // $$\bumpeq$$

// C

bin := "\Cap"                   // $$\Cap$$
bin := "\cdot"                  // $$\cdot$$
bin := "\cdotp"                 // $$\cdotp$$
cmp := "\circeq"                // $$\circeq$$
bin := "\circledast"            // $$\circledast$$
bin := "\circledcirc"           // $$\circledcirc$$
bin := "\circleddash"           // $$\circleddash$$
cmp := "\cong"                  // $$\cong$$
bin := "\coprod"                // $$\coprod$$
bin := "\Cup"                   // $$\Cup$$
cmp := "\curlyeqprec"           // $$\curlyeqprec$$
cmp := "\curlyeqsucc"           // $$\curlyeqsucc$$
bin := "\curlyvee"              // $$\curlyvee$$
bin := "\curlywedge"            // $$\curlywedge$$

// D

arr := "\dashleftarrow"         // $$\dashleftarrow$$
arr := "\dashrightarrow"        // $$\dashrightarrow$$
bin := "\divideontimes"         // $$\divideontimes$$
cmp := "\doteq"                 // $$\doteq$$
cmp := "\Doteq"                 // $$\Doteq$$
cmp := "\doteqdot"              // $$\doteqdot$$
bin := "\dotplus"               // $$\dotplus$$
bin := "\doublebarwedge"        // $$\doublebarwedge$$
bin := "\doublecap"             // $$\doublecap$$
bin := "\doublecup"             // $$\doublecup$$
bin := "\Downarrow"             // $$\Downarrow$$
bin := "\downarrow"             // $$\downarrow$$
bin := "\downdownarrows"        // $$\downdownarrows$$
bin := "\downharpoonleft"       // $$\downharpoonleft$$
bin := "\downharpoonright"      // $$\downharpoonright$$

// E

cmp := "\eqcirc"                // $$\eqcirc$$
cmp := "\eqsim"                 // $$\eqsim$$
cmp := "\eqslantgtr"            // $$\eqslantgtr$$
cmp := "\eqslantless"           // $$\eqslantless$$
cmp := "\equiv"                 // $$\equiv$$

// F

bin := "\fallingdotseq"         // $$\fallingdotseq$$

// G

cmp := "\geqslant"              // $$\geqslant$$
arr := "\gets"                  // $$\gets$$
cmp := "\gg"                    // $$\gg$$
cmp := "\ggg"                   // $$\ggg$$
cmp := "\gggtr"                 // $$\gggtr$$
cmp := "\gnapprox"              // $$\gnapprox$$
cmp := "\gnsim"                 // $$\gnsim$$
cmp := "\gtrapprox"             // $$\gtrapprox$$
cmp := "\gtrdot"                // $$\gtrdot$$
cmp := "\gtreqless"             // $$\gtreqless$$
cmp := "\gtreqqless"            // $$\gtreqqless$$
cmp := "\gtrless"               // $$\gtrless$$
cmp := "\gtrsim"                // $$\gtrsim$$
cmp := "\gvertneqq"             // $$\gvertneqq$$

// H

arr := "\hookleftarrow"         // $$\hookleftarrow$$
arr := "\hookrightarrow"        // $$\hookrightarrow$$

// I

// J

bin := "\Join"                  // $$\Join$$

// K

// L

arr := "\leadsto"               // $$\leadsto$$
arr := "\Leftarrow"             // $$\Leftarrow$$
arr := "\leftarrow"             // $$\leftarrow$$
arr := "\leftarrowtail"         // $$\leftarrowtail$$
arr := "\leftharpoondown"       // $$\leftharpoondown$$
arr := "\leftharpoonup"         // $$\leftharpoonup$$
arr := "\leftleftarrows"        // $$\leftleftarrows$$
arr := "\Leftrightarrow"        // $$\Leftrightarrow$$
arr := "\leftrightarrow"        // $$\leftrightarrow$$
cmp := "\leftrightarrows"       // $$\leftrightarrows$$
cmp := "\leftrightharpoons"     // $$\leftrightharpoons$$
arr := "\leftrightsquigarrow"   // $$\leftrightsquigarrow$$
cmp := "\leqslant"              // $$\leqslant$$
cmp := "\lessapprox"            // $$\lessapprox$$
cmp := "\lessdot"               // $$\lessdot$$
cmp := "\lesseqgtr"             // $$\lesseqgtr$$
cmp := "\lesseqqgtr"            // $$\lesseqqgtr$$
cmp := "\lessgtr"               // $$\lessgtr$$
cmp := "\lesssim"               // $$\lesssim$$
arr := "\Lleftarrow"            // $$\Lleftarrow$$
cmp := "\lll"                   // $$\lll$$
cmp := "\llless"                // $$\llless$$
cmp := "\lnapprox"              // $$\lnapprox$$
cmp := "\lnot"                  // $$\lnot$$
cmp := "\lnsim"                 // $$\lnsim$$
arr := "\Longleftarrow"         // $$\Longleftarrow$$
arr := "\longleftarrow"         // $$\longleftarrow$$
arr := "\Longleftrightarrow"    // $$\Longleftrightarrow$$
arr := "\longleftrightarrow"    // $$\longleftrightarrow$$
arr := "\longmapsto"            // $$\longmapsto$$
arr := "\Longrightarrow"        // $$\Longrightarrow$$
arr := "\longrightarrow"        // $$\longrightarrow$$
cmp := "\ltimes"                // $$\ltimes$$
cmp := "\lvertneqq"             // $$\lvertneqq$$

// M

arr := "\mapsto"                // $$\mapsto$$

// N

cmp := "\ncong"                 // $$\ncong$$
cmp := "\ngeqslant"             // $$\ngeqslant$$
cmp := "\ni"                    // $$\ni$$
cmp := "\nleqslant"             // $$\nleqslant$$
cmp := "\nparallel"             // $$\nparallel$$
cmp := "\nprec"                 // $$\nprec$$
cmp := "\npreceq"               // $$\npreceq$$
cmp := "\nsim"                  // $$\nsim$$
cmp := "\nsucc"                 // $$\nsucc$$
cmp := "\nsucceq"               // $$\nsucceq$$
cmp := "\ntriangleleft"         // $$\ntriangleleft$$
cmp := "\ntrianglelefteq"       // $$\ntrianglelefteq$$
cmp := "\ntriangleright"        // $$\ntriangleright$$
cmp := "\ntrianglerighteq"      // $$\ntrianglerighteq$$

// O

bin := "\odot"                  // $$\odot$$
bin := "\ominus"                // $$\ominus$$
bin := "\oplus"                 // $$\oplus$$
bin := "\oslash"                // $$\oslash$$
//bin := "\otimes"              // $$\otimes$$

// P

cmp := "\perp"                  // $$\perp$$
bin := "\pm"                    // $$\pm$$
cmp := "\prec"                  // $$\prec$$
cmp := "\precapprox"            // $$\precapprox$$
cmp := "\preccurlyeq"           // $$\preccurlyeq$$
cmp := "\preceq"                // $$\preceq$$
cmp := "\precnapprox"           // $$\precnapprox$$
cmp := "\precneqq"              // $$\precneqq$$
cmp := "\precnsim"              // $$\precnsim$$
cmp := "\precsim"               // $$\precsim$$
bin := "\prod"                  // $$\prod$$
cmp := "\propto"                // $$\propto$$

// Q

// R

cmp := "\rhd"                   // $$\rhd$$
arr := "\Rightarrow"            // $$\Rightarrow$$
arr := "\rightarrow"            // $$\rightarrow$$
arr := "\rightarrowtail"        // $$\rightarrowtail$$
arr := "\rightharpoondown"      // $$\rightharpoondown$$
arr := "\rightharpoonup"        // $$\rightharpoonup$$
arr := "\rightleftarrows"       // $$\rightleftarrows$$
arr := "\rightleftharpoons"     // $$\rightleftharpoons$$
arr := "\rightleftharpoons"     // $$\rightleftharpoons$$
arr := "\rightrightarrows"      // $$\rightrightarrows$$
arr := "\rightsquigarrow"       // $$\rightsquigarrow$$
arr := "\Rrightarrow"           // $$\Rrightarrow$$
cmp := "\rtimes"                // $$\rtimes$$

// S

bin := "\setminus"              // $$\setminus$$
cmp := "\sim"                   // $$\sim$$
cmp := "\simeq"                 // $$\simeq$$
cmp := "\smallsetminus"         // $$\smallsetminus$$
bin := "\sqcap"                 // $$\sqcap$$
bin := "\sqcup"                 // $$\sqcup$$
cmp := "\sqsubset"              // $$\sqsubset$$
cmp := "\sqsubseteq"            // $$\sqsubseteq$$
cmp := "\sqsupset"              // $$\sqsupset$$
cmp := "\sqsupseteq"            // $$\sqsupseteq$$
bin := "\square"                // $$\square$$
cmp := "\Subset"                // $$\Subset$$
cmp := "\succ"                  // $$\succ$$
cmp := "\succapprox"            // $$\succapprox$$
cmp := "\succcurlyeq"           // $$\succcurlyeq$$
cmp := "\succeq"                // $$\succeq$$
cmp := "\succnapprox"           // $$\succnapprox$$
cmp := "\succneqq"              // $$\succneqq$$
cmp := "\succnsim"              // $$\succnsim$$
cmp := "\succsim"               // $$\succsim$$
cmp := "\Supset"                // $$\Supset$$

// T

cmp := "\thickapprox"           // $$\thickapprox$$
cmp := "\thicksim"              // $$\thicksim$$
bin := "\times"                 // $$\times$$
arr := "\to"                    // $$\to$$
bin := "\triangle"              // $$\triangle$$
bin := "\triangledown"          // $$\triangledown$$
cmp := "\triangleleft"          // $$\triangleleft$$
cmp := "\trianglelefteq"        // $$\trianglelefteq$$
cmp := "\triangleq"             // $$\triangleq$$
cmp := "\triangleright"         // $$\triangleright$$
cmp := "\trianglerighteq"       // $$\trianglerighteq$$
arr := "\twoheadleftarrow"      // $$\twoheadleftarrow$$
arr := "\twoheadrightarrow"     // $$\twoheadrightarrow$$

// U

cmp := "\unlhd"                // $$\unlhd$$
cmp := "\unrhd"                // $$\unrhd$$
bin := "\Uparrow"              // $$\Uparrow$$
bin := "\uparrow"              // $$\uparrow$$
bin := "\Updownarrow"          // $$\Updownarrow$$
bin := "\updownarrow"          // $$\updownarrow$$
bin := "\upharpoonleft"        // $$\upharpoonleft$$
bin := "\upharpoonright"       // $$\upharpoonright$$
bin := "\uplus"                // $$\uplus$$
bin := "\upuparrows"           // $$\upuparrows$$

// V

cmp := "\varsubsetneq"         // $$\varsubsetneq$$
cmp := "\varsubsetneqq"        // $$\varsubsetneqq$$
cmp := "\varsupsetneq"         // $$\varsupsetneq$$
cmp := "\varsupsetneqq"        // $$\varsupsetneqq$$
cmp := "\veebar"               // $$\veebar$$

// W

// X

arr := "\xleftarrow"           // $$\xleftarrow$$
arr := "\xrightarrow"          // $$\xrightarrow$$

// Y

// Z

// The precedences here are a hack: so many operators.
// The general effect is: except for keyword logic connectives,
// these operations are all done AFTER any ASCII art ops
// and, only one is allowed per sub-expression: you must use parens
// if you use more than one. We'll fix this for some key operations later,
// particularly the setwise and logic connectors. However, the comparisons
// are at the right precedence.
// (fact is, I don't know what half the operators are for anyhow .. )

x[stuple_pri] := x[>stuple_pri] "\brace" x[>stuple_pri] =># "(Infix)";
x[stuple_pri] := x[>stuple_pri] "\brack" x[>stuple_pri] =># "(Infix)";

x[scomparison_pri]:= x[>scomparison_pri] bin x[>scomparison_pri]
// set ops (note: no setminus, its a standard binop at the moment ;)
// note: no \Cap or other variants .. would interfere with chain
// there's no reason at all to chain these anyhow, they're standard left assoc operators

// All arrows are right associative .. hmm ..
x[sarrow_pri] := x[scase_literal_pri] arr x[sarrow_pri]