layout: true class: typo, typo-selection --- count: false class: nord-dark, middle, center # 📚 Lecture 04c - Affine Arithmetic @luk036 👨‍💻 · 2026 📅 --- class: center, middle # 🔺 A Simple Example: Triangle Area Calculation --- ### 📏 A Simple Area Problem - Points $p$, $q$, and $r$ vary within 3 given rectangular regions - **Q**: What are the upper/lower bounds of $\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: center, middle # 🔄 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:#4caf50 style B fill:#ff9800 style C fill:#f44336 style D fill:#f44336 style E fill:#2196f3 style F fill:#4caf50 </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 --- ### 📚 What is Affine Arithmetic? **Affine Form**: $$\hat{x} = x_0 + x_1 \epsilon_1 + \ldots + x_n \epsilon_n$$ where: - $\epsilon_i \in [-1, 1]$ (noise symbols) - $x_0$: central value - $x_i$: partial deviations **Example Conversion**: IA [3..4] → $3.5 + 0.5 \epsilon_1$ --- ### 📐 Geometry of AA .pull-left70[ - Affine forms that share noise symbols are dependent: - $\hat{x} = x_0 + x_1 \epsilon_1 + \ldots + x_n \epsilon_n$ - $\hat{y} = y_0 + y_1 \epsilon_1 + \ldots + y_m \epsilon_m$ - The region containing (x, y) is: - $Z = \{(x, y) : \epsilon_i \in [-1, 1]\}$ - This region is a centrally symmetric convex polygon called "zonotope". ] .pull-right30[  ] --- # Affine Arithmetic How to find $\sup_{q \in {\mathbb{Q} } } f_j(x,q)$ efficiently? - $\sup_{q \in {\mathbb{Q} } } f_j(x,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): $$\hat{a} = a_0 + a_1 \varepsilon_1 + a_2 \varepsilon_2 + \cdots + a_k \varepsilon_k = a_0 + \sum_{i=1}^{k} a_i \varepsilon_i,$$ where - $\varepsilon_i \in [-1, 1]$ is called *noise symbol*. - Exact results for affine operations ($\hat{a}+\hat{b}$, $\hat{a}-\hat{b}$ and $\alpha \cdot \hat{a}$) - Results of non-affine operations (such as $\hat{a} \cdot \hat{b}$, $\hat{a}/\hat{b}$, $\max(\hat{a}, \hat{b}), \log(\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 $q$ in affine forms. For each ellipsoid iteration, $f(x_c,q)$ is obtained by *approximating* $f(x_c,\hat{q})$ in an affine form: $$\hat{f} = f_0 + f_1 \varepsilon_1 + f_2 \varepsilon_2 + \cdots + f_k \varepsilon_k.$$ Then the maximum of $\hat{f}$ is determined by: $$\varepsilon_j = \left\{ \begin{array}{ll} +1 & \qquad \text{if} \; f_j > 0 \\ -1 & \qquad \text{if} \; f_j < 0 \end{array} \right. \quad j=1, \cdots, k.$$ --- .pull-left70[  ] --- ### 🎯 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 $A_v$ can be approximated as a monomial function: $$A_v = \frac{2 C_{ox} }{(\lambda_n + \lambda_p)^2} \sqrt{\mu_n \mu_p \frac{W_1 W_6}{L_1 L_6 I_1 I_6} }$$ where $I_1$ and $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 | | ---------- | ------ | ------- | ----- | ------ | | $W_1$ | μm | 44.8 | 44.9 | 45.4 | | $W_8$ | μm | 3.94 | 3.98 | 3.8 | | $W_{10}$ | μm | 2.0 | 2.0 | 2.0 | | $W_{13}$ | μm | 2.0 | 2.0 | 2.1 | | $L_1$ | μm | 1.0 | 1.0 | 1.0 | | $L_8$ | μm | 1.0 | 1.0 | 1.0 | | $L_{10}$ | μm | 1.0 | 1.0 | 1.0 | | $L_{13}$ | μm | 1.0 | 1.0 | 1.0 | | $A$ | N/A | 10.4 | 10.3 | 12.0 | | $B$ | N/A | 61.9 | 61.3 | 69.1 | | $C_c$ | pF | 1.0 | 1.0 | 1.0 | | $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 $V_{DD}$) | [0.1, 0.9] | [0.07, 0.92] | [0.07, 0.92] | | Comm Inp Range (x $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[  ]