Fix invalid math formulas in quantization doc

[Lewuathe]

Summary

A single backslash is not properly escaped in the web documentation. We can make sure to escape for rendering subscripts.

Additionally, it also fixed the mal-formed equations in "Affine to fixed point" and "Fixed point to affine" sections. With this fix, the page is rendered as follows.

[mehdi_amini]

This makes it quite heavy to write, it there something we could change on the website generator side to avoid changing it here?

[Lewuathe]

@mehdi_amini We may be able to avoid rewriting the double dollar mark ($$) by changing the inlineMath config in mlir-www. But I think that contradicts the convention of LaTex in general.

For escaping the backslash, we may be able to use processEscapes config for MathJax. That can reduce the amount of change.

Formatting issue (e.g. L.152-156) can only be resolved by putting begin/end{align*} as far as I know.

[mehdi_amini]

In D101252#2715958, @Lewuathe wrote:

For escaping the backslash, we may be able to use processEscapes config for MathJax. That can reduce the amount of change.

Yeah that's the one I was mostly thinking of with my previous comment, wanna send a PR for the MathJax config?

[mehdi_amini]

(otherwise LGTM)

[Lewuathe]

I tried to use processEscapes option of MathJax. But it did not work as expected. It only handles the literal dollar sign and has no impact to escape the underscore in the math equation, unfortunately.
Looking into the whole configuration, there seems to be no other options we may be able to use for this case.

https://docs.mathjax.org/en/v2.7-latest/options/preprocessors/tex2jax.html

[mehdi_amini]

Alright, thanks for trying, feel free to land it as-is then!

[Lewuathe]

@mehdi_amini Thank you for reviewing! I do not have a right to merge this change into the repository. Could you do that on behalf of me?

mlir/docs/Quantization.md

*   *per-axis* (also called *per-channel*) : Applying individually to each index
     along a specific axis of a tensor type.
 
 ### Fixed point values
 
 [Fixed point](https://en.wikipedia.org/wiki/Fixed-point_arithmetic) values are a
 [Real](https://en.wikipedia.org/wiki/Real_number) number divided by a *scale*.
 We will call the result of the divided real the *scaled value*.
 
-$$ real\_value = scaled\_value * scale $$
+$$ real\\_value = scaled\\_value * scale $$
 
 The scale can be interpreted as the distance, in real units, between neighboring
-scaled values. For example, if the scale is $$ \pi $$, then fixed point values
-with this scale can only represent multiples of $$ \pi $$, and nothing in
+scaled values. For example, if the scale is $ \pi $, then fixed point values
+with this scale can only represent multiples of $ \pi $, and nothing in
 between. The maximum rounding error to convert an arbitrary Real to a fixed
-point value with a given $$ scale $$ is $$ \frac{scale}{2} $$. Continuing the
-previous example, when $$ scale = \pi $$, the maximum rounding error will be $$
-\frac{\pi}{2} $$.
+point value with a given $ scale $ is $ \frac{scale}{2} $. Continuing the
+previous example, when $ scale = \pi $, the maximum rounding error will be $
+\frac{\pi}{2} $.
 
 Multiplication can be performed on scaled values with different scales, using
 the same algorithm as multiplication of real values (note that product scaled
 value has $$ scale_{product} = scale_{left \mbox{ } operand} * scale_{right
 \mbox{ } operand} $$). Addition can be performed on scaled values, so long as
 they have the same scale, using the same algorithm for addition of real values.
 This makes it convenient to represent scaled values on a computer as signed
 integers, and perform arithmetic on those signed integers, because the results
 will be correct scaled values.
 
 ### Affine values
 
 Mathematically speaking, affine values are the result of
 [adding a Real-valued *zero point*, to a scaled value](https://en.wikipedia.org/wiki/Affine_transformation#Representation).
 Alternatively (and equivalently), subtracting a zero point from an affine value results in a
 scaled value:
 
-$$ real\_value = scaled\_value * scale = (affine\_value - zero\_point) * scale $$
+$$ real\\_value = scaled\\_value * scale = (affine\\_value - zero\\_point) * scale $$
 
 Essentially, affine values are a shift of the scaled values by some constant
 amount. Arithmetic (i.e., addition, subtraction, multiplication, division)
 cannot, in general, be directly performed on affine values; they must first be
 [converted](#affine-to-fixed-point) to the equivalent scaled values.
 
 As alluded to above, the motivation for using affine values is to more
 efficiently represent real values that will actually be encountered during
 computation. Frequently, real values that will be encountered are not
 symmetric around the real zero. We also make the assumption that the real zero
 is encountered during computation, and should thus be represented.
 
 In this case, it is inefficient to store scaled values represented by signed
 integers, as some of the signed integers will never be used. In effect, the bit patterns
 corresponding to those signed integers are going to waste.
 
 In order to exactly represent the real zero with an integral-valued affine
 value, the zero point must be an integer between the minimum and maximum affine
 value (inclusive). For example, given an affine value represented by an 8 bit
-unsigned integer, we have: $$ 0 \leq zero\_point \leq 255$$. This is important,
+unsigned integer, we have: $ 0 \leq zero\\_point \leq 255 $. This is important,
 because in convolution-like operations of deep neural networks, we frequently
 need to zero-pad inputs and outputs, so zero must be exactly representable, or
 the result will be biased.
 
 ### Relation
 
 Real values, fixed point values, and affine values relate through the following
 equation, which demonstrates how to convert one type of number to another:
 
-$$ real\_value = scaled\_value * scale = (affine\_value - zero\_point) * scale $$
+$$ real\\_value = scaled\\_value * scale = (affine\\_value - zero\\_point) * scale $$
 
 Note that computers generally store mathematical values using a finite number of
 bits. Thus, while the above conversions are exact, to store the result in a
 finite number of bits, we must, in general, round the result of the conversion
 (this applies to both cases: storing using floating point and storing using
 fixed point). Note that a full discussion of rounding behavior is outside the
 scope of this document, and it is safe to assume unless otherwise stated that
 rounding should be according to the IEEE754 default of RNE (where hardware

 floating point format, frequently
 [Single precision](https://en.wikipedia.org/wiki/Single-precision_floating-point_format))
 to a tensor of affine elements represented by an integral type (e.g. 8-bit
 unsigned integer), the following conversion can be performed (note that it is
 not required that all representable values of the integral type are used):
 
 $$
 \begin{align*}
-af&fine\_value_{uint8 \, or \, uint16} \\
-      &= clampToTargetSize(roundToNearestInteger( \frac{real\_value_{Single}}{scale_{Single}})_{sint32} + zero\_point_{uint8 \, or \, uint16})
+af&fine\\_value_{uint8 \\, or \\, uint16} \\\\
+      &= clampToTargetSize(roundToNearestInteger( \frac{real\\_value_{Single}}{scale_{Single}})_{sint32} + zero\\_point_{uint8 \, or \, uint16})
 \end{align*}
 $$
 
-In the above, we assume that $$real\_value$$ is a Single, $$scale$$ is a Single,
-$$roundToNearestInteger$$ returns a signed 32-bit integer, and $$zero\_point$$
+In the above, we assume that $real\\_value$ is a Single, $scale$ is a Single,
+$roundToNearestInteger$ returns a signed 32-bit integer, and $zero\\_point$
 is an unsigned 8-bit or 16-bit integer. Note that bit depth and number of fixed
 point values are indicative of common types on typical hardware but is not
 constrained to particular bit depths or a requirement that the entire range of
 an N-bit integer is used.
 
 #### Affine to real
 
 To convert an output tensor of affine elements represented by uint8
 or uint16 to a tensor of real-valued elements (usually represented with a
 floating point format, frequently Single precision), the following conversion
 can be performed:
 
 $$
 \begin{align*}
-re&al\_value_{Single} \\
-      &= roundToNearestFloat((affine\_value_{uint8 \, or \, uint16} - zero\_point_{uint8 \, or \, uint16})_{sint32})_{Single} * scale_{Single}
+re&al\\_value_{Single} \\\\
+      &= roundToNearestFloat((affine\\_value_{uint8 \\, or \\, uint16} - zero\\_point_{uint8 \\, or \\, uint16})_{sint32})_{Single} * scale_{Single}
 \end{align*}
 $$
 
 In the above, we assume that the result of subtraction is in 32-bit signed
-integer format, and that $$roundToNearestFloat$$ returns a Single.
+integer format, and that $roundToNearestFloat$ returns a Single.
 
 #### Affine to fixed point
 
 When the affine and fixed point scales are the same, subtract the zero point
 from the affine value to get the equivalent fixed point value.
 
-$$
-scaled\_value = affine\_value_{non\mbox{-}negative} - zero\_point_{non\mbox{-}negative}
+$$ 
+\begin{align*}
+  scaled\\_value = affine\\_value_{non\mbox{-}negative} - zero\\_point_{non\mbox{-}negative}
+\end{align*}
 $$
 
 #### Fixed point to affine
 
 When the affine and fixed point scales are the same, add the zero point to the
 fixed point value to get the equivalent affine value.
 
-$$
-affine\_value_{non\mbox{-}negative} = scaled\_value + zero\_point_{non\mbox{-}negative}
+$$ 
+\begin{align*}
+  affine\\_value_{non\mbox{-}negative} = scaled\\_value + zero\\_point_{non\mbox{-}negative} 
+\end{align*}
 $$
 
 ## Usage within MLIR
 
 There are several components to the quantization system being developed within
 MLIR:
 
 *   *Quantization* dialect containing: