#set document(title: "2.4 Arc Length", author: "XYZ Homework")
#set page(width: 8.5in, height: auto, margin: 1in)
#import "@preview/cetz:0.5.2"
#set text(font: ("STIX Two Text", "Libertinus Serif", "New Computer Modern"), size: 10.5pt, lang: "en")
#show math.equation: set text(font: ("STIX Two Math", "New Computer Modern Math"))
#set par(justify: true, leading: 0.62em, spacing: 0.9em)
#set enum(spacing: 1.1em)   // room between list items so tall inline fractions don't collide
#set list(spacing: 1.1em)
#set table(stroke: 0.5pt + rgb("#c7ccd3"))

#let BLUE = rgb("#183B6F")     // brand navy — section bars + example/solution labels (white on navy 11.09:1)
#let ORANGE = rgb("#A94509")   // brand primary-700 — AA-safe deep orange for TEXT (5.93:1 on white; raw brand #F37021 is 2.94:1 and must never carry text)
#let RED = rgb("#DC2626")      // brand error-600
#let GREEN = rgb("#059669")    // brand success-600 (decoration only; small green text uses green-text #007942)

#show heading.where(level: 1): it => block(width: 100%, above: 0pt, below: 16pt,
  fill: gradient.linear(BLUE, rgb("#2C5AA0")), inset: (x: 14pt, y: 12pt), radius: 3pt,
  text(fill: white, weight: "bold", size: 19pt, it.body))
#show heading.where(level: 2): it => block(width: 100%, above: 18pt, below: 10pt,
  fill: BLUE, inset: (x: 10pt, y: 6pt), radius: 2pt,
  text(fill: white, weight: "bold", size: 12pt, it.body))
#show heading.where(level: 3): it => text(fill: ORANGE, weight: "bold", size: 12.5pt, it.body)
#show heading.where(level: 4): it => text(fill: BLUE, weight: "bold", size: 10.5pt, it.body)

#let examplebox(label, title, body) = block(width: 100%, breakable: true,
  fill: rgb("#EFF1F5"), stroke: 0.5pt + rgb("#CFDDF0"), radius: 4pt, inset: 10pt,
  above: 12pt, below: 12pt)[
  #block(below: 6pt)[#box(fill: BLUE, inset: (x: 6pt, y: 2pt), radius: 2pt,
    text(fill: white, weight: "bold", size: 8.5pt, label)) #h(0.4em) #strong[#title]]
  #body]

// rail = decorative left rule (raw brand token); labelcolor = AA-safe label text shade
#let notebox(label, rail, labelcolor, tint, body) = block(width: 100%, breakable: true, fill: tint,
    stroke: (left: 3pt + rail), inset: (left: 10pt, rest: 8pt), radius: (right: 4pt),
    above: 11pt, below: 11pt)[
    #text(fill: labelcolor, weight: "bold", size: 7.5pt, tracking: 0.5pt)[#upper(label)]
    #linebreak() #body]

#let solutionbox(body) = block(above: 4pt, below: 8pt)[
  #text(fill: BLUE, weight: "bold", size: 8.5pt)[Solution] #linebreak() #body]

#let figph(msg) = block(width: 100%, height: 60pt, fill: rgb("#f6f7f9"),
  stroke: (paint: rgb("#c7ccd3"), dash: "dashed"), radius: 4pt, inset: 10pt)[
  #align(center + horizon, text(fill: rgb("#889"), style: "italic", size: 9pt, msg))]

// Standardize inlined figure sizes: measure the natural CeTZ canvas, then scale to a
// consistent envelope (aspect-aware; see build_typst.py FIG_* constants). Unlike the
// print preamble, dimensions are FLOORED: in an editor a user can trim a figure to a
// degenerate 1-D shape (a bare line), and w/h or tw/w would then divide by zero.
#let _STD_W = 3.5
#let _WIDE_W = 5.6
#let _MAX_H = 3.4
#let _ASPECT_WIDE = 2.2
#let _UPSCALE_MAX = 1.15
#let stdfig(body) = context {
  let m = measure(body)
  let w = calc.max(m.width / 1in, 0.01)
  let h = calc.max(m.height / 1in, 0.01)
  let tw = if w / h > _ASPECT_WIDE { _WIDE_W } else { _STD_W }
  let s = calc.min(tw / w, _MAX_H / h, _UPSCALE_MAX)
  align(center, box(scale(x: s * 100%, y: s * 100%, reflow: true, body)))
}

#show figure: set block(breakable: false)
#set figure(gap: 8pt)
#show figure.caption: set text(size: 8.5pt, fill: rgb("#555"))


    
== 2.4#h(0.6em)Arc Length


    #notebox("Note", rgb("#8a94a6"), rgb("#556666"), rgb("#f7f8fa"))[
#emph[Objectives]


      - Explain arc length as the limit of inscribed chord-polygon lengths.
- Derive the arc length integral from the chord sum via the derivative.
- Compute the exact length of a helix and compare it against a coarse chord estimate.
]


    How long is a curve? The honest answer starts with something you can actually measure: straight segments. Pick sample points along the curve, connect neighbors by chords, and add up the chord lengths. The result — the length of an #strong[inscribed polygon] — is a slight underestimate, since each chord shortcuts its arc. Refine the sampling and the polygon hugs the curve ever more closely; #strong[arc length] is the limit of the chord sums.


    The figure below stages the definition on the helix from earlier in this chapter, drawn twice: once finely sampled, so it reads as the smooth curve, and once from only eight sample points, so it #emph[is] the inscribed polygon.


    
      {"camera":{"fov":50,"position":\[6,4.5,4\],"projection":"perspective","target":\[0,0,1.5\]},"grid":{"axisColors":{"x":"\#ef4444","y":"\#22c55e","z":"\#3b82f6"},"divisions":10,"gridColor":"\#e5e7eb","showAxes":true,"showLabels":true,"size":10,"visible":true},"id":"56436649-8234-495a-af74-64308be8c624","metadata":{"alt\_text":"A smooth red helix winding two full turns up around the z-axis, threaded by a blue chain of seven straight segments whose corners all lie exactly on the helix: the same curve sampled at only eight points, so the blue path is the inscribed chord polygon that arc length is defined from. The blue shortcut visibly hugs the inside of every red turn, making the polygon slightly shorter than the curve it approximates.","created\_at":"2026-08-01T00:00:00.000Z","description":"Authored book scene: the helix (cos t, sin t, t/4) for t in \[0, 4 pi\] drawn twice as parametric curves, once at 500 samples (the smooth curve) and once at 8 samples (the coarse inscribed polygon of chords), so the reader can compare chord-sum length against true arc length.","tags":\["book","calc3","parametric-curve","arc-length","helix"\],"updated\_at":"2026-08-01T00:00:00.000Z"},"objects":\[{"id":"f0d3fce5-5136-4a8a-9d84-a5bc5cbbc827","kind":"parametric-curve","label":{"text":"helix r(t) = (cos t, sin t, t/4), 500 samples","visible":true},"samples":500,"style":{"color":"\#ef4444","dash":\[\],"lineWidth":4},"tDomain":\[0,12.566370614359172\],"visible":true,"xExpr":"cos(t)","yExpr":"sin(t)","zExpr":"t/4"},{"id":"faee316f-3bca-468c-b60d-f2b90afe26d0","kind":"parametric-curve","label":{"text":"same helix, 8 samples: the inscribed chord polygon","visible":true},"samples":8,"style":{"color":"\#1d4ed8","dash":\[\],"lineWidth":3},"tDomain":\[0,12.566370614359172\],"visible":true,"xExpr":"cos(t)","yExpr":"sin(t)","zExpr":"t/4"}\],"title":"Arc length: a helix and its inscribed chord polygon","version":1}
      The helix #math.equation(block: false, alt: "open parenthesis cos t , sin t , t / 4 close parenthesis")[$( cos t , sin t , t / 4 )$] over two full turns, drawn smooth (red, 500 samples) and as its own inscribed chord polygon (blue, 8 samples — seven chords). The blue path cuts inside every turn of the red one.
    
    
=== Explore


    + Orbit until you can sight along one turn of the helix. Where does each blue chord sit relative to the red arc it replaces — inside or outside? What does that say about the sign of the error in a chord-sum estimate?
+ The seven chords look congruent. Use the symmetry of the helix to explain why they must be.
+ Roughly estimate one chord's length against the grid, multiply by seven, and hold onto the number — the example below computes what the fine curve converges to.


    
=== From chord sum to integral


    Now let calculus take the limit. On a fine partition #math.equation(block: false, alt: "t sub 0 , t sub 1 , … , t sub n")[$t_(0) , t_(1) , … , t_(n)$], the chord from #math.equation(block: false, alt: "𝐫 open parenthesis t sub k minus 1 close parenthesis")[$𝐫 ( t_(k − 1) )$] to #math.equation(block: false, alt: "𝐫 open parenthesis t sub k close parenthesis")[$𝐫 ( t_(k) )$] has length approximately #math.equation(block: false, alt: "‖ 𝐫 prime open parenthesis t sub k close parenthesis ‖ Δ t")[$‖ 𝐫^(′) ( t_(k) ) ‖ Δ t$] — displacement is velocity times elapsed time, when the elapsed time is short. The chord sum is then a Riemann sum, and its limit is


    #math.equation(block: true, alt: "L equals ∫ a b ‖ 𝐫 prime open parenthesis t close parenthesis ‖ d t equals ∫ a b the square root of f prime open parenthesis t close parenthesis squared plus g prime open parenthesis t close parenthesis squared plus h prime open parenthesis t close parenthesis squared d t .")[$L = ∫_(a)^(b) ‖ 𝐫^(′) ( t ) ‖ d t = ∫_(a)^(b) sqrt(f^(′) ( t )^(2) + g^(′) ( t )^(2) + h^(′) ( t )^(2)) #h(0.278em) d t .$]


    The integrand #math.equation(block: false, alt: "‖ 𝐫 prime open parenthesis t close parenthesis ‖")[$‖ 𝐫^(′) ( t ) ‖$] is the #emph[speed] of the moving point, so the formula says something you already believed: distance traveled is speed integrated over time. For plane curves #math.equation(block: false, alt: "h equals 0")[$h = 0$] and the same formula covers the cycloid and rose of the playground section.


    #examplebox("Example 1")[Exact length of the helix, and the polygon's verdict][
Find the length of #math.equation(block: false, alt: "𝐫 open parenthesis t close parenthesis equals open parenthesis cos t , sin t , t / 4 close parenthesis")[$𝐫 ( t ) = ( cos t , sin t , t / 4 )$] for #math.equation(block: false, alt: "t ∈ [ 0 , 4 π ]")[$t ∈ [ 0 , 4 π ]$], and compare with the seven-chord polygon in the figure above.


      Differentiate componentwise: #math.equation(block: false, alt: "𝐫 prime open parenthesis t close parenthesis equals open parenthesis minus sin t , cos t , 1 / 4 close parenthesis")[$𝐫^(′) ( t ) = ( − sin t , cos t , 1 / 4 )$], so the speed is


        #math.equation(block: true, alt: "‖ 𝐫 prime open parenthesis t close parenthesis ‖ equals the square root of sin squared t plus cos squared t plus the fraction 1 over 16 equals the square root of the fraction 17 over 16 equals the fraction the square root of 17 over 4 ,")[$‖ 𝐫^(′) ( t ) ‖ = sqrt(sin^(2) t + cos^(2) t + frac(1, 16)) = sqrt(frac(17, 16)) = frac(sqrt(17), 4) ,$]


        a constant — the helix is traced at uniform speed, which is also why the polygon's chords are congruent. Therefore


        #math.equation(block: true, alt: "L equals ∫ 0 4 π the fraction the square root of 17 over 4 d t equals π the square root of 17 approximately equals 12.95 .")[$L = ∫_(0)^(4 π) frac(sqrt(17), 4) d t = π sqrt(17) ≈ 12.95 .$]


        For the polygon, the eight samples are equally spaced in #math.equation(block: false, alt: "t")[$t$] with step #math.equation(block: false, alt: "Δ t equals 4 π / 7")[$Δ t = 4 π / 7$], and the chord between consecutive samples has length #math.equation(block: false, alt: "the square root of 2 minus 2 cos Δ t plus open parenthesis π / 7 close parenthesis squared approximately equals 1.63")[$sqrt(2 − 2 cos Δ t + ( π / 7 )^(2)) ≈ 1.63$], so the polygon measures about #math.equation(block: false, alt: "7 times 1.63 approximately equals 11.4")[$7 × 1.63 ≈ 11.4$] — noticeably under the true #math.equation(block: false, alt: "12.95")[$12.95$], exactly the shortfall your eye predicted from the chords cutting inside the turns. At three and a half chords per turn the polygon is still crude; refining to a few dozen samples closes the gap to within a pixel's worth of length.
]


    #notebox("Note", rgb("#8a94a6"), rgb("#556666"), rgb("#f7f8fa"))[
The integral is not a new idea — it is the chord sum with the bookkeeping taken to the limit. When an arc length integral looks opaque, picture the blue polygon it is refining.
]