Norm

Norms help us quantify the size of a vector or the distance between two. Whether you’re navigating city blocks (L1) or flying straight to your destination (L2), norms are the compass that keep our linear algebra adventures grounded. 📏

L1-norm

The L1-norm (also known as the Manhattan distance) measures the total absolute difference between two vectors— or from the origin if one vector is zero.

\| \mathbf{u} - \mathbf{v} \|_1 = \sum_{i=1}^n |u_i - v_i|

L2-norm

The L2-norm (also known as the Euclidean distance) measures the straight-line distance between two vectors— or from the origin if one vector is zero.

\| \mathbf{u} - \mathbf{v} \|_2 = \sqrt{ \sum_{i=1}^n (u_i - v_i)^2 }

One Vector

viewof sv1 = Inputs.range([-8, 8], {
  step: 0.5, 
  value: 4, 
  label: tex`v_1`, 
  width: 180
})

viewof sv2 = Inputs.range([-8, 8], {
  step: 0.5, 
  value: 3, 
  label: tex`v_2`, 
  width: 180
})

// Calculate norms (single vector)
singleNorms = {
  // L1-norm (Manhattan distance from origin)
  const l1_norm = Math.abs(sv1) + Math.abs(sv2);
  
  // L2-norm (Euclidean distance from origin)
  const l2_norm = Math.sqrt(sv1 * sv1 + sv2 * sv2);
  
  return {
    l1_norm, l2_norm
  };
}

// Display vector and norms (single)
html`<div style="text-align: center; font-size: 1.2em; margin: 1.5em 0;">
  <p>
    ${tex`\mathbf{v} = \begin{bmatrix} ${sv1} \\ ${sv2} \end{bmatrix}`}
  </p>
  <p style="margin-top: 1em;">
    ${tex`||\mathbf{v}||_1 = ${singleNorms.l1_norm.toFixed(3)}, \quad ||\mathbf{v}||_2 = ${singleNorms.l2_norm.toFixed(3)}`}
  </p>
</div>`

singleManhattanPath = [
  {x: 0, y: 0},    // Start at origin
  {x: sv1, y: 0},   // Move horizontally first
  {x: sv1, y: sv2}   // Then move vertically to vector endpoint
]

// Norm visualization plot (single vector)
Plot.plot({
  style: "overflow: visible; display: block; margin: 0 auto;",
  width: 700,
  height: 600,
  grid: true,
  x: {label: "x_1", domain: [-10, 10]},
  y: {label: "x_2", domain: [-10, 10]},
  marks: [
    // Grid axes
    Plot.ruleY([0], {stroke: "#ddd"}),
    Plot.ruleX([0], {stroke: "#ddd"}),
    
    // Vector v (blue arrow)
    Plot.arrow([{x1: 0, y1: 0, x2: sv1, y2: sv2}], {
      x1: "x1", y1: "y1", x2: "x2", y2: "y2",
      stroke: "steelblue", strokeWidth: 4, fill: "steelblue"
    }),
    
    // L2-norm: Direct line from origin to vector endpoint (green)
    Plot.line([{x: 0, y: 0}, {x: sv1, y: sv2}], {
      x: "x", y: "y",
      stroke: "green", strokeWidth: 3, strokeOpacity: 0.6, strokeDasharray: "5,5"
    }),
    
    // L1-norm: Manhattan path from origin to vector endpoint (orange)
    Plot.line(singleManhattanPath, {
      x: "x", y: "y",
      stroke: "orange", strokeWidth: 4, strokeOpacity: 0.8
    }),
    
    // Origin point
    Plot.dot([{x: 0, y: 0}], {
      x: "x", y: "y",
      r: 4,
      fill: "black",
      stroke: "white", strokeWidth: 2
    }),
    
    // Vector endpoint
    Plot.dot([{x: sv1, y: sv2}], {
      x: "x", y: "y",
      r: 6,
      fill: "steelblue",
      stroke: "white", strokeWidth: 2
    }),
    
    // Corner point for Manhattan distance
    Plot.dot([{x: sv1, y: 0}], {
      x: "x", y: "y", r: 3, fill: "orange", stroke: "white"
    }),
    
    // Vector label
    Plot.text([
      {x: sv1/2 + 0.3, y: sv2/2 + 0.3, text: "v"}
    ], {
      x: "x", y: "y", text: "text",
      fontSize: 16, fontWeight: "bold", fill: "steelblue"
    }),
    
    // Norm labels
    Plot.text([
      {x: sv1/2 - 0.5, y: sv2/2 - 0.5, text: `L₂ = ${singleNorms.l2_norm.toFixed(2)}`},
      {x: sv1/2, y: -0.8, text: `L₁ = ${singleNorms.l1_norm.toFixed(2)}`}
    ], {
      x: "x", y: "y", text: "text",
      fontSize: 12, fontWeight: "bold",
      fill: d => d.text.includes("L₂") ? "green" : "orange"
    }),
    
    // Component labels
    Plot.text([
      {x: sv1/2, y: -0.3, text: `|${sv1}|`},
      {x: sv1 + 0.3, y: sv2/2, text: `|${sv2}|`}
    ], {
      x: "x", y: "y", text: "text",
      fontSize: 11, fill: "orange", fontStyle: "italic"
    })
  ]
})

Two Vectors

viewof du1 = Inputs.range([-8, 8], {
  step: 0.5, 
  value: 3, 
  label: tex`u_1`, 
  width: 180
})

viewof du2 = Inputs.range([-8, 8], {
  step: 0.5, 
  value: 2, 
  label: tex`u_2`, 
  width: 180
})

// Vector v components (two vector tab)
viewof dv1 = Inputs.range([-8, 8], {
  step: 0.5, 
  value: -1, 
  label: tex`v_1`, 
  width: 180
})

viewof dv2 = Inputs.range([-8, 8], {
  step: 0.5, 
  value: 4, 
  label: tex`v_2`, 
  width: 180
})

// Calculate norms (two vectors)
doubleNorms = {
  // Difference vector
  const diff1 = du1 - dv1;
  const diff2 = du2 - dv2;
  
  // L1-norm (Manhattan distance)
  const l1_norm = Math.abs(diff1) + Math.abs(diff2);
  
  // L2-norm (Euclidean distance)
  const l2_norm = Math.sqrt(diff1 * diff1 + diff2 * diff2);
  
  return {
    diff1, diff2, l1_norm, l2_norm
  };
}

// Display vectors and norms (two vectors)
html`<div style="text-align: center; font-size: 1.2em; margin: 1.5em 0;">
  <p>
    ${tex`\mathbf{u} = \begin{bmatrix} ${du1} \\ ${du2} \end{bmatrix}, \quad \mathbf{v} = \begin{bmatrix} ${dv1} \\ ${dv2} \end{bmatrix}`}
  </p>
  <p style="margin-top: 1em;">
    ${tex`||\mathbf{u} - \mathbf{v}||_1 = ${doubleNorms.l1_norm.toFixed(3)}, \quad ||\mathbf{u} - \mathbf{v}||_2 = ${doubleNorms.l2_norm.toFixed(3)}`}
  </p>
</div>`

doubleManhattanPath = [
  {x: dv1, y: dv2}, // Start at v
  {x: du1, y: dv2}, // Move horizontally to align with u
  {x: du1, y: du2}  // Move vertically to u
]

// Norm visualization plot (two vectors)
Plot.plot({
  style: "overflow: visible; display: block; margin: 0 auto;",
  width: 700,
  height: 600,
  grid: true,
  x: {label: "x_1", domain: [-10, 10]},
  y: {label: "x_2", domain: [-10, 10]},
  marks: [
    // Grid axes
    Plot.ruleY([0], {stroke: "#ddd"}),
    Plot.ruleX([0], {stroke: "#ddd"}),
    
    // Vector u (blue)
    Plot.arrow([{x1: 0, y1: 0, x2: du1, y2: du2}], {
      x1: "x1", y1: "y1", x2: "x2", y2: "y2",
      stroke: "steelblue", strokeWidth: 3, fill: "steelblue"
    }),
    
    // Vector v (red)
    Plot.arrow([{x1: 0, y1: 0, x2: dv1, y2: dv2}], {
      x1: "x1", y1: "y1", x2: "x2", y2: "y2",
      stroke: "crimson", strokeWidth: 3, fill: "crimson"
    }),
    
    // L2-norm: Direct line from v to u (green)
    Plot.line([{x: dv1, y: dv2}, {x: du1, y: du2}], {
      x: "x", y: "y",
      stroke: "green", strokeWidth: 4, strokeOpacity: 0.8
    }),
    
    // L1-norm: Manhattan path from v to u (orange)
    Plot.line(doubleManhattanPath, {
      x: "x", y: "y",
      stroke: "orange", strokeWidth: 4, strokeOpacity: 0.8
    }),
    
    // Vector endpoints
    Plot.dot([
      {x: du1, y: du2, color: "u"},
      {x: dv1, y: dv2, color: "v"}
    ], {
      x: "x", y: "y",
      r: 6,
      fill: d => d.color === "u" ? "steelblue" : "crimson",
      stroke: "white", strokeWidth: 2
    }),
    
    // Corner point for Manhattan distance
    Plot.dot([{x: du1, y: dv2}], {
      x: "x", y: "y", r: 3, fill: "orange", stroke: "white"
    }),
    
    // Vector labels
    Plot.text([
      {x: du1/2, y: du2/2 + 0.5, text: "u"},
      {x: dv1/2, y: dv2/2 - 0.5, text: "v"}
    ], {
      x: "x", y: "y", text: "text",
      fontSize: 16, fontWeight: "bold"
    }),
    
    // Distance labels
    Plot.text([
      {x: (du1 + dv1)/2 - 0.8, y: (du2 + dv2)/2 + 0.5, text: `L₂ = ${doubleNorms.l2_norm.toFixed(2)}`},
      {x: (du1 + dv1)/2 + 1.2, y: dv2 - 0.5, text: `L₁ = ${doubleNorms.l1_norm.toFixed(2)}`}
    ], {
      x: "x", y: "y", text: "text",
      fontSize: 12, fontWeight: "bold",
      fill: d => d.text.includes("L₂") ? "green" : "orange"
    })
  ]
})