layout: true class: typo, typo-selection --- count: false class: nord-dark, middle, center # 📚 Lecture 04c - Affine Arithmetic @luk036 👨‍💻 · 2026 📅 --- class: nord-light, middle, center ## 🔺 A Simple Example: Triangle Area Calculation --- ### 📏 A Simple Area Problem - Points ${\color{coral}p}$, ${\color{coral}q}$, and ${\color{coral}r}$ vary within 3 given rectangular regions - **Q**: What are the upper/lower bounds of ${\color{salmon}\triangle pqr}$ area?  --- ### 🔳 Method 1: Corner-based Approach - Calculate areas for all corner combinations - **Issues**: - 🧩 Combinatorial explosion with many variables - ⚠️ Worst-case may not occur at corners - ⏳ Computationally expensive for high dimensions --- ### 🎰 Method 2: Monte Carlo Simulation - Randomly sample points within variation ranges - Calculate area for each sample - **Pros**: - 📊 More accurate with more samples - **Cons**: - ⏱️ Time-consuming - No guarantees of finding true bounds --- class: nord-light, middle, center ## 🔄 Interval vs. Affine Arithmetic --- .mermaid[ <pre> graph TB A(("Uncertain Inputs")) --> B{Affine or Interval?} B -->|Interval Arithmetic| C[No Correlation Tracking] C --> D[Overestimated Bounds] B -->|Affine Arithmetic| E[Shared Noise Symbols] E --> F[Tighter Bounds] style A fill:#c8e6c9,stroke:#2e7d32,stroke-width:3px style B fill:#fff3e0,stroke:#e65100,stroke-width:3px style C fill:#ffcdd2,stroke:#c62828,stroke-width:3px style D fill:#ffcdd2,stroke:#c62828,stroke-width:3px style E fill:#e3f2fd,stroke:#1565c0,stroke-width:3px style F fill:#c8e6c9,stroke:#2e7d32,stroke-width:3px </pre> ] --- ### 🧮 Method 3: Interval Arithmetic (IA) **Example Calculation**: - px = [2, 3], py = [3, 4] - qx = [-5, -4], qy = [-6, -5] - rx = [6, 7], ry = [-5, -4] **Area Calculation**: - ((qx-px)(ry-py) - (qy-py)(rx-px))/2 - IA result: [33..61] (Actual: [36.5..56.5]) **Limitation**: ❌ Cannot handle variable correlations --- ### ➕ Method 4: Affine Arithmetic (AA) **Advantages**: - ✅ Handles first-order correlations - 🎯 More accurate than IA (e.g., [35..57] in example) - ⚡ Faster than Monte Carlo for small variations **Implementation**: - Public library: `libaffa.a`/YALAA - Supports: +, -, *, /, sin(), cos(), pow(), etc. --- ### 🔌 Analog Circuit Example **Unit Gain Bandwidth**: `GBW = sqrt(A*Kp*Ib*(W2/L2)/(2*pi*Cc)` where parameters have manufacturing variations --- ### 💻 Enabling Technologies **C++ Template Metaprogramming**: ```cpp template <typename Tp> Tp area(const Tp& px, const Tp& qx, const Tp& rx, const Tp& py, const Tp& qy, const Tp& ry) { return ((qx-px)*(ry-py) - (qy-py)*(rx-px)) / 2; } ``` - Same code works for both `double` and `AAF` types - Enables code reuse with minimal modifications --- ### 🛠️ Applications of AA - 🎛️ Analog Circuit Sizing - ⏱️ Worst-Case Timing Analysis - 📊 Statistical Static Timing Analysis - 🔌 Parameter Variation Interconnect Modeling [CMU02] - ⏰ Clock Skew Analysis - 🕰️ Bounded Skew Clock Tree Synthesis --- ### ⚠️ Limitations of AA **Functional Limitations**: - 🔄 No iterative methods (no fixed point in AA) - ➗ No multiplicative inverse (no LU decomposition) - 🔢 No total ordering (can't sort) **Mathematical Limitations**: - 📉 Only handles linear correlations - ❌ Poor approximation of `abs(x)` near zero ✅ Fortunately the ellipsoid method is one of the few algorithms that works with AA. --- ### 🏗️ Circuit Sizing for Op Amp **Methodology**: 1. Geometric Programming formulation 2. Min-max convex programming under PVT variations 3. Ellipsoid Method optimization --- class: nord-light, middle, center ## 📚 Affine Arithmetic Theory --- ### 📚 What is Affine Arithmetic? **Affine Form**: $${\color{darkblack}\hat{x}} = {\color{orange}x_0} + {\color{darkblack}x_1} {\color{blue}\epsilon_1} + \ldots + {\color{darkblack}x_n} {\color{blue}\epsilon_n}$$ where: - ${\color{blue}\epsilon_i} \in [-1, 1]$ (noise symbols) - ${\color{orange}x_0}$: central value - ${\color{darkblack}x_i}$: partial deviations **Example Conversion**: IA [3..4] → $3.5 + 0.5 {\color{blue}\epsilon_1}$ --- ### 📐 Geometry of AA .pull-left70[ - Affine forms that share noise symbols are dependent: - ${\color{darkblack}\hat{x}} = {\color{orange}x_0} + {\color{darkblack}x_1} {\color{blue}\epsilon_1} + \ldots + {\color{darkblack}x_n} {\color{blue}\epsilon_n}$ - ${\color{darkblack}\hat{y}} = {\color{orange}y_0} + {\color{darkblack}y_1} {\color{blue}\epsilon_1} + \ldots + {\color{darkblack}y_m} {\color{blue}\epsilon_m}$ - The region containing (x, y) is: - ${\color{salmon}Z} = \{({\color{darkblack}x}, {\color{darkblack}y}) : {\color{blue}\epsilon_i} \in [-1, 1]\}$ - This region is a centrally symmetric convex polygon called "zonotope". ] .pull-right30[  ] --- ### ➕ Affine Arithmetic How to find $\sup_{{\color{coral}q} \in {\color{salmon}\mathbb{Q} } } f_j({\color{green}x},{\color{coral}q})$ efficiently? - $\sup_{{\color{coral}q} \in {\color{salmon}\mathbb{Q} } } f_j({\color{green}x},{\color{coral}q})$ is in general difficult to obtain. - Provided that variations are small or nearly linear, we propose using Affine Arithmetic (AA) to solve this problem. - Features of AA: - Handle correlation of variations by sharing *noise symbols*. - Enabling technology: template and operator overloading features of C++. - A C++ package "YALAA" is publicly available. --- ### 🔍 AA for Worst Case Analysis - An uncertain quantity is represented in an affine form (AAF): $${\color{darkblack}\hat{a}} = {\color{orange}a_0} + {\color{darkblack}a_1} {\color{blue}\varepsilon_1} + {\color{darkblack}a_2} {\color{blue}\varepsilon_2} + \cdots + {\color{darkblack}a_k} {\color{blue}\varepsilon_k} = {\color{orange}a_0} + \sum_{i=1}^{{\color{coral}k} } {\color{darkblack}a_i} {\color{blue}\varepsilon_i},$$ where - ${\color{blue}\varepsilon_i} \in [-1, 1]$ is called *noise symbol*. - Exact results for affine operations (${\color{darkblack}\hat{a}}+{\color{darkblack}\hat{b}}$, ${\color{darkblack}\hat{a}}-{\color{darkblack}\hat{b}}$ and ${\color{coral}\alpha} \cdot {\color{darkblack}\hat{a}}$) - Results of non-affine operations (such as ${\color{darkblack}\hat{a}} \cdot {\color{darkblack}\hat{b}}$, ${\color{darkblack}\hat{a}}/{\color{darkblack}\hat{b}}$, $\max({\color{darkblack}\hat{a}}, {\color{darkblack}\hat{b}}), \log({\color{darkblack}\hat{a}})$) are *approximated* in an affine form. - AA has been applied to a wide range of applications recently when process variations are considered. --- ### ⚙️ AA for Optimization In our robust GP problem: AA is used in worst-case scenario analysis to determine the maximum and minimum values of a function subject to variations in its inputs. First, represent every elements in ${\color{coral}q}$ in affine forms. For each ellipsoid iteration, $f({\color{green}x_c},{\color{coral}q})$ is obtained by *approximating* $f({\color{green}x_c},{\color{darkblack}\hat{q}})$ in an affine form: $${\color{darkblack}\hat{f}} = {\color{orange}f_0} + {\color{darkblack}f_1} {\color{blue}\varepsilon_1} + {\color{darkblack}f_2} {\color{blue}\varepsilon_2} + \cdots + {\color{darkblack}f_k} {\color{blue}\varepsilon_k}.$$ Then the maximum of ${\color{darkblack}\hat{f}}$ is determined by: $${\color{blue}\varepsilon_j} = \left\{ \begin{array}{ll} +1 & \qquad \text{if} \; {\color{darkblack}f_j} > 0 \\ -1 & \qquad \text{if} \; {\color{darkblack}f_j} < 0 \end{array} \right. \quad j=1, \cdots, {\color{coral}k}.$$ --- .pull-left70[  ] --- class: nord-light, middle, center ## 📊 Design Example & Results --- ### 🎯 Performance Specifications .column-2.font-sm.mb-xs[ | Constraint | Spec. | Units | |------------------|---------------|---------------| | Device Width | ≥ 2.0 | μm | | Device Length | ≥ 1.0 | μm | | Area | minimize | μm² | | Input CM Voltage | [0.45,0.55] | × VDD | | Output Range | [0.1,0.9] | × VDD | | Gain | ≥ 80 | dB | | Unity Gain Freq. | ≥ 50 | MHz | | Phase Margin | ≥ 60 | degrees | | Slew Rate | ≥ 50 | V/$\mu$s | | CMRR | ≥ 75 | dB | | Neg. PSRR | ≥ 80 | dB | | Power | $\leq 3$ | mW | | Noise, Flicker | $\leq 800$ | nV/Hz$^{0.5}$ | ] --- ### 📈 Open-Loop Gain Example - Open-loop gain ${\color{coral}A_v}$ can be approximated as a monomial function: $${\color{coral}A_v} = \frac{2 {\color{orange}C_{ox}} }{({\color{orange}\lambda_n} + {\color{orange}\lambda_p})^2} \sqrt{{\color{orange}\mu_n} {\color{orange}\mu_p} \frac{{\color{green}W_1} {\color{green}W_6}}{{\color{green}L_1} {\color{green}L_6} {\color{coral}I_1} {\color{coral}I_6} }$$ where ${\color{coral}I_1}$ and ${\color{coral}I_6}$ are monomial functions. - Corresponding C++ code fragment: ```cpp // Open Loop Gain monomial<aaf> OLG = 2*COX/square(LAMBDAN+LAMBDAP)* sqrt(KP*KN*W[1]/L[1]*W[6]/L[6]/I1/I6); ``` --- ### 📊 Design Variable Results .column-2.font-sm.mb-xs[ | Variable | Units | GGPLAB | Our | Robust | | ---------- | ------ | ------- | ----- | ------ | | ${\color{green}W_1}$ | μm | 44.8 | 44.9 | 45.4 | | ${\color{green}W_8}$ | μm | 3.94 | 3.98 | 3.8 | | ${\color{green}W_{10}}$ | μm | 2.0 | 2.0 | 2.0 | | ${\color{green}W_{13}}$ | μm | 2.0 | 2.0 | 2.1 | | ${\color{green}L_1}$ | μm | 1.0 | 1.0 | 1.0 | | ${\color{green}L_8}$ | μm | 1.0 | 1.0 | 1.0 | | ${\color{green}L_{10}}$ | μm | 1.0 | 1.0 | 1.0 | | ${\color{green}L_{13}}$ | μm | 1.0 | 1.0 | 1.0 | | ${\color{coral}A}$ | N/A | 10.4 | 10.3 | 12.0 | | ${\color{coral}B}$ | N/A | 61.9 | 61.3 | 69.1 | | ${\color{coral}C_c}$ | pF | 1.0 | 1.0 | 1.0 | | ${\color{coral}I_{bias}}$ | μA | 6.12 | 6.19 | 5.54 | ] --- ### 🏆 Performance Comparison .font-sm.mb-xs[ | Performance (units) | Spec. | Std. | Robust | | ------------------------------ | ------------ | ------------ | ------------ | | Estimated Area ($\mu$m$^2$) | minimize | 5678.4 | 6119.2 | | Output Range (x ${\color{coral}V_{DD}}$) | [0.1, 0.9] | [0.07, 0.92] | [0.07, 0.92] | | Comm Inp Range (x ${\color{coral}V_{DD}}$) | [0.45, 0.55] | [0.41, 0.59] | [0.39, 0.61] | | Gain (dB) | $\geq 80$ | 80 | [80.0, 81.1] | | Unity Gain Freq. (MHz) | $\geq 50$ | 50 | [50.0, 53.1] | | Phase Margin (degree) | $\geq 60$ | 86.5 | [86.1, 86.6] | | Slew Rate (V/$\mu$s) | $\geq 50$ | 64 | [66.7, 66.7] | | CMRR (dB) | $\geq 75$ | 77.5 | [77.5, 78.6] | | Neg. PSRR (dB) | $\geq 80$ | 83.5 | [83.5, 84.6] | | Power (mW) | $\leq 3$ | 1.5 | [1.5, 1.5] | | Noise, Flicker (nV/Hz$^{0.5}$) | $\leq 800$ | $600$ | [578, 616] | ] --- ### 🎯 Conclusions - ⚡ Fast computation (<1 sec on 3GHz CPU) - 🛡️ Guaranteed worst-case performance - 📈 Robust GP formulation handles variations - 🏗️ Ellipsoid method provides reliable solutions --- ### 💭 Final Comments - ➕ AA excels for small/near-linear variations - 🧩 Combines well with zonotope geometry - ⚠️ Not universal - incompatible with: - 🔄 Iterative methods - ➗ Matrix inversions - 🔄 Best combined with other methods (Monte Carlo) --- count: false class: nord-dark, middle, center .pull-left[ ## Q&A 🎤 ] .pull-right[  ]