VC.05 Flow Measurements by Integrals
 BASICS

\(Off[General::spell]; 
Off[General::spell1]; 

    \(Off[ParametricPlot3D::ppcom]; \)\)Off[ParametricPlot::ppcom]; Off[Plot::plnr]; SetOptions[Limit, Analytic -> True];

CMView = {2.7, 1.6, 1.2};

Vector Drawer

BeginPackage["Vector3D`", "Graphics`Colors`"];

\(Axes3D::"usage" = 
      "Axes3D[a, b] creates a Graphics3D object of cartesian axes with x, y, and z running from -a/3 to a, and with axes labels b units beyond the tips of the axes.  Axes3D[a] is Axes3D[a, a/8]."; 

    \(Perpend::"usage" = 
      "Perpend[a] returns a unit vector which is perpendicular to the vector a."; \)\)Arrow::"usage" = 
      "Arrow[a] produces a 2 or 3 dimensional vector from the origin to a. \
Arrow[a, Tail -> tail] gives a vector from tail to a."; Vector::"usage" = 
      "Vector[a, b] gives a 2D or 3D vector from a to b."; ArrowHead::"usage" = 
      "ArrowHead[a, vec] produces an arrowhead with its tip placed at the \
point a, pointing in the direction of the vector vec."; Tail::"usage" = 
      "Tail -> point puts the tail of the vector at point."; Norm::"usage" = 
      "Norm[vec] returns the Euclidean length of vec."; Normalize::"usage" = 
      "Normalize[vec] returns a unit vector in the direction of vec, \
provided vec is nonzero."; Aperture::"usage" = 
      "Aperture is the ratio of the radius of the base to the length of the \
head of a vector."; TipSize::"usage" = 
      "TipSize specifies an absolute size for the inner tip length of the \
head of a vector."; TipRatio::"usage" = 
      "TipRatio is the ratio of the inner length of the arrowhead to the \
length of the shaft of a vector."; HeadRatio::"usage" = 
      "HeadRatio is the ratio of the outer length of the arrowhead to the \
length of the shaft of a vector."; HeadSize::"usage" = 
      "HeadSize specifies an absolute size for the head of a vector."; 
    ScaleFactor::"usage" = 
      "ScaleFactor specifies the amount to scale a vector in length and may \
be either a number or a pure function."; ZeroVectorPointSize::"usage" = 
      "ZeroVectorPointSize is the size of the point used to represent a \
zero vector."; Options[Vector] = 
      Options[Arrow] = 
        Options[ArrowHead] = {HeadRatio -> 0.18, 
            TipRatio -> 0.14, Aperture -> 0.3, 
            ScaleFactor -> 1, HeadType -> Polygon, 
            ShaftQ -> True, EdgesQ -> True, 
            VectorColor -> RGBColor[0, 0, 1], ShaftWidth -> 0.005, 
            ZeroVectorPointSize -> 0.01}; Begin["`Private`"]; SetOptions[ParametricPlot, AspectRatio -> Automatic]; SetOptions[Plot, AspectRatio -> Automatic]; SetOptions[Graphics, AspectRatio -> Automatic]; Axes3D[u_, v_] := 
      Graphics3D[{{Blue, Line[{{-(u/3), 0, 0}, {u, 0, 0}}]}, 
          Text["x", {u + v, 0, 0}], {Blue, 
            Line[{{0, -(u/3), 0}, {0, u, 0}}]}, 
          Text["y", {0, u + v, 0}], {Blue, 
            Line[{{0, 0, -(u/3)}, {0, 0, u}}]}, 
          Text["z", {0, 0, u + v}]}]; Axes3D[u_] := Axes3D[u, (u/8)]; Norm[a_?VectorQ] := N[(Sqrt[a . a])]; Normalize[a_?VectorQ] := If[a . a == 0, a, (a/Norm)[a]]; Perpend[a_?VectorQ] := 
      Normalize[{a[[2]], 
            -a[[1]]}] /; 
        Length[a] == 2Perpend[a_?VectorQ] := 
      Normalize[
          If[a[[1]] == 0, {1, 0, 0}, {0, 
              a[[3]], 
              -a[[2]]}]] /; 
        Length[a] == 3Base3D = 
      Table[{Cos[((2 k π)/8.) ], Sin[((2 k π)/8.) ]}, {k, 0, 
          8}]; Vector[from_?VectorQ, to_?VectorQ, opts___] := 
      Module[{sq, sw, ht, hs, hr, tr, ap, sf, vc, zvps, diff = to - from, 
            tip}, {sq, sw, ht, hs, hr, ts, tr, ap, sf, vc, zvps} = 
            {ShaftQ, ShaftWidth, HeadType, HeadSize, HeadRatio, TipSize, 
                  TipRatio, Aperture, ScaleFactor, VectorColor, 
                  ZeroVectorPointSize} /. {opts} /. Options[Vector]; 
          If[from == to, 
            Return[Graphics[{PointSize[zvps], vc, Point[from]}]]]; 
          diff = If[NumberQ[N[sf]], sf diff, sf[diff]]; tip = from + diff; 
          If[NumberQ[hs], hr = (hs/Norm)[diff]; tr = 0.75 hr]; 
          If[NumberQ[ts], tr = (ts/Norm)[diff]]; 
          Graphics[{
              If[sq, {vc, Thickness[sw], Line[{from, tip - tr diff}]}, {}], 
              With[{trans = ap hr Norm[diff] Perpend[diff]}, {vc, 
                  Thickness[sw], 
                  ht[{tip, tip - hr diff + trans, tip - tr diff, 
                      tip - hr diff - trans, tip}]}]}]] /; 
        Length[from] == Length[to] == 2Vector[from_?VectorQ, to_?VectorQ, opts___] := 
      Module[{sq, eq, sw, hs, hr, tr, ap, sf, vc, zvps, diff = to - from, 
            tip}, {sq, eq, sw, hs, hr, ap, sf, vc, zvps} = 
            {ShaftQ, EdgesQ, ShaftWidth, HeadSize, HeadRatio, Aperture, 
                  ScaleFactor, VectorColor, ZeroVectorPointSize} /. {opts}
                   /. Options[Vector]; 
          If[from == to, 
            Return[Graphics3D[{PointSize[zvps], vc, Point[from]}]]]; 
          diff = If[NumberQ[N[sf]], sf diff, sf[diff]]; tip = from + diff; 
          If[NumberQ[hs], hr = (hs/Norm)[diff]]; tr = (hr/2); 
          Graphics3D[{
              If[sq, {vc, Thickness[sw], Line[{from, tip - tr diff}]}, {}], 
              If[eq, {}, EdgeForm[]], {SurfaceColor[vc], 
                With[{temp = Perpend[diff]}, 
                  (Polygon[Append[#1, tip]]&)/@
                    Partition[
                      (tip - hr diff + #1&)/@
                        ((ap hr Norm[diff] Base3D) . {temp, 
                              Normalize[temp\[Cross]diff]}), 2, 1]]}}]] /; 
        Length[from] == Length[to] == 3Arrow[a_, Tail -> b_, opts___] := Vector[b, a + b, opts]Arrow[a_, opts___] := Vector[Table[0, {Length[a]}], a, opts]\(ArrowHead[a_, b_, opts___] := 
      Vector[a - b, a, ShaftQ -> False, opts]; 

End[]; 

    \(EndPackage[]; \)\)

Graphics`Colors`GosiaGreen = RGBColor[0,  0.392187,  0];

Spherical Setup

\(Clear[polar]; 

    polar[{x_, y_, z_}] := {\@\(x\^2 + y\^2 + z\^2\), ArcTan[y\/x], 
        ArcCos[z\/\@\(x\^2 + y\^2 + z\^2\)]}; 
Clear[X, length]; 

    length[X_] := \@\(X . X\); 
\(rr = 3; \)\)R = 5; scale = 0.8; red = RGBColor[1, 0, 0]; blue = RGBColor[0, 0, 1]; color1 = RGBColor[0.8, 0.2, 0.8]; color2 = RGBColor[0.2, 0.8, 0.2]; black = RGBColor[0, 0, 0]; \(Clear[axes]; 

    axes := Graphics3D[{Line[{X, {1.5\ rr, 0, 0}}], 
          Line[{X, {0, 1.5\ rr, 0}}], Line[{X, {0, 0, 2\ rr}}]}]; 

    Clear[xyplane]; 

    xyplane := 
      Graphics3D[
        Polygon[{{\(-2\)\ rr, \(-2\)\ rr, 0}, {\(-2\)\ rr, 2\ rr, 0}, {2\ rr, 
              2\ rr, 0}, {2\ rr, \(-2\)\ rr, 0}}]]; 
\(X = {0, 0, 0}; \)\)origin = Graphics3D[{black, Point[X]}]; Z = {2, 3, 5}; \(Clear[point]; 

    point := Graphics3D[{red, PointSize[0.03], Point[scale\ Z]}]; 

    \(Z0 = {0, 0, length[0.8\ Z]}; \)\)\(Clear[zpoint]; 
zpoint = Graphics3D[{black, Point[Z0]}]; 

    \(XY = scale\ Z\ {1, 1, 0}; \)\)\(Clear[xypoint]; 
xypoint := Graphics3D[{black, Point[XY]}]; 

    \(X0 = {length[scale\ Z\ {1, 1, 0}], 0, 0}; \)\)xpoint = Graphics3D[{black, Point[X0]}]; Y0 = {0, length[scale Z {1, 1, 0}], 0}; ypoint = Graphics3D[{black, Point[Y0]}]; \(Clear[ray]; 
ray := Graphics3D[{blue, Line[{X, scale\ Z}]}]; 

    Clear[ray1]; 
ray1 := Graphics3D[{color1, Line[{scale\ Z, Z}]}]; 

    Clear[xyray]; 
xyray := Graphics3D[{red, Line[{X, Z\ {1, 1, 0}}]}]; 

    \(rays := {ray, xyray}; \)\)xyaux = 
      (length[0.8 Z] (0.8 Z {1, 1, 0}))/
        length[0.8 Z {1, 1, 0}]; \(Clear[zarc]; 

    zarc = Graphics3D[{blue, 
          Line[Table[
              \(Cos[t]\ \) {0, 0, length[0.8\ Z]} + Sin[t]\ xyaux, {t, 0, 
                \(polar[0.8\ Z]\)[[3
                  ]],  .1}]]}]; 
Clear[zarc1]; 

    zarc1 = Graphics3D[{color1, 
          Line[Table[
              \(Cos[t]\ \) {0, 0, length[0.8\ Z]} + Sin[t]\ xyaux, {t, 
                \(polar[0.8\ Z]\)[[3]], 
                1,  .1}]]}]; 
Clear[zarc2]; 

    zarc2 = Graphics3D[{color1, 
          Line[Table[
              \(Cos[t]\ \) {0, 0, length[0.8\ Z]} + Sin[t]\ xyaux, {t, 
                \(-0.8\), 0,  .1}]]}]; 
Clear[xyarc]; 

    xyarc = Graphics3D[{blue, 
          Line[Table[
              Cos[t]\ X0 + Sin[t]\ Y0, {t, 0, 
                \(polar[XY]\)[[2
                  ]],  .1}]]}]; 
Clear[xyarc1]; 

    xyarc1 = Graphics3D[{color1, 
          Line[Table[Cos[t]\ X0 + Sin[t]\ Y0, {t, \(- .5\), 0,  .1}]]}]; 

    Clear[xyarc2]; 

    xyarc2 = Graphics3D[{color1, 
          Line[Table[
              Cos[t]\ X0 + Sin[t]\ Y0, {t, 
                \(polar[XY]\)[[2]], 
                \(polar[XY]\)[[2]] + 
                  0.3,  .1}]]}]; 
Clear[stick]; 

    stick = Graphics3D[{red, Line[{scale\ Z, XY}]}]; 

    \(xaxislabel = Text["x", {0.363, 0.26}]; \)\)yaxislabel = Text["y", {0.73, 0.3}]; zaxislabel = Text["z", { .5, 0.67}]; stickplot = 
      Show[xyplane, axes, ray, point, Boxed -> False, 
        ViewPoint -> {2.747, 1.594, 1.168}, 
        Epilog -> {xaxislabel, yaxislabel, zaxislabel}, 
        DisplayFunction -> Identity]; rho = Text["r", {0.53, 0.45}]; rlabel = 
      Show[xyplane, axes, ray, point, Boxed -> False, 
        ViewPoint -> {2.747, 1.594, 1.168}, 
        Epilog -> {rho, xaxislabel, yaxislabel, zaxislabel}, 
        DisplayFunction -> Identity]; phi = Text["s", {0.55, 0.57}]; slabel = 
      Show[xyplane, zpoint, axes, ray, point, zarc, zarc1, zarc2, 
        Boxed -> False, ViewPoint -> {2.747, 1.594, 1.168}, 
        Epilog -> {phi, xaxislabel, yaxislabel, zaxislabel}, 
        DisplayFunction -> Identity]; theta = Text["t", { .5, 0.3}]; tlabel = 
      Show[xyplane, axes, xypoint, xpoint, ray, stick, point, xyarc, xyarc1, 
        xyarc2, Boxed -> False, ViewPoint -> {2.747, 1.594, 1.168}, 
        Epilog -> {theta, xaxislabel, yaxislabel, zaxislabel}, 
        DisplayFunction -> Identity]; all = 
      Show[xyplane, axes, ray, stick, point, zpoint, xpoint, xypoint, xyarc, 
        xyarc1, xyarc2, zarc, zarc1, zarc2, Boxed -> False, 
        ViewPoint -> {2.747, 1.594, 1.168}, 
        Epilog -> {theta, phi, rho, xaxislabel, yaxislabel, zaxislabel}, 
        DisplayFunction -> Identity];

Crisscross

\(Clear[x]; 

    crisscross = 
      Plot[{Cos[x], Sin[x]}, {x, π\/8, \(3\ π\)\/8}, 
        PlotStyle -> {{RGBColor[1, 0, 0], Thickness[0.02]}}, 
        Axes -> None, AspectRatio -> 1\/3, 
        DisplayFunction -> Identity]; \)

B.1) Measuring flow across a curve with the integral   
       (∫_tlow^thigh)(Field[x[t], y[t]].{y'[t],-x'[t]})dt

Here's a vector field:

\(Clear[Field, m, n, x, y]; 
m[x_, y_] = 0.8\ Sin[y]; 

    n[x_, y_] = 0.4\ x + 0.1\ y; 

Field[x_, y_] = {m[x, y], n[x, y]}\)

Here's a curve:

\(Clear[t]; 
{x[t_], y[t_]} = {2\ Cos[t], Sin[t]}; 
tlow = 0; 

    thigh = 2\ π; 


    curveplot = 
      ParametricPlot[{x[t], y[t]}, {t, tlow, thigh}, 
        PlotStyle -> {{Thickness[0.01], Red}}, 
        AxesLabel -> {"x", "y"}]; \)

Pick a point on the curve, say {x[(π/4)],y[(π/4)]}, and look at the field vector at this point:

tt = (π/4); \(Clear[setup]; 

    setup[t_] := 
      Show[curveplot, Arrow[Field[x[t], y[t]], Tail -> {x[t], y[t]}], 
        DisplayFunction -> Identity]; 


    Show[setup[tt], DisplayFunction -> $DisplayFunction]; \)

Now look at the curve with a little segment of fluid centered at the base of the field vector:

Clear[fluidbit, center, height, width, h];
unittan[t_]=(({x'[t],y'[t]})/(Sqrt[((x'[t])^2)+((y'[t])^2)]));

center[t_] = {x[t], y[t]};

fluidbit[center_, t_, h_] := 
        Graphics[{Thickness[0.015], Blue, 
            Line[{center - h unittan[t], center + h unittan[t]}]}];

h = 0.2;
Show[setup[tt], fluidbit[center[tt], tt, h], PlotRange -> All, 
        DisplayFunction -> $DisplayFunction];

When you check out how the fluid segment moves in a short time you'll see approximately this:

flowtime = 0.4; Show[setup[tt], 
      fluidbit[center[tt] + flowtime Field[x[tt], y[tt]], tt, h], 
      DisplayFunction -> $DisplayFunction];

Grab the last two plots and animate.
To get an even better idea, put a microscope on it:

\(Show[setup[tt], fluidbit[center[tt], tt, h], 
      PlotRange 
        -> {{x[tt] - 4\ h, x[tt] + 4\ h}, {y[tt] - 4\ h, y[tt] + 4\ h}}, 
      DisplayFunction -> $DisplayFunction]; 


    Show[setup[tt], 
      fluidbit[center[tt] + flowtime\ Field[x[tt], y[tt]], tt, h], 
      PlotRange 
        -> {{x[tt] - 4\ h, x[tt] + 4\ h}, {y[tt] - 4\ h, y[tt] + 4\ h}}, 
      DisplayFunction -> $DisplayFunction]; \)

Grab the last two plots and animate, running at a slow speed. 
Now look at both together:

Show[setup[tt], fluidbit[center[tt], tt, h], 
      fluidbit[center[tt] + flowtime Field[x[tt], y[tt]], tt, h], 
      PlotRange 
        -> {{x[tt] - 4 h, x[tt] + 4 h}, {y[tt] - 4 h, y[tt] + 4 h}}, 
      DisplayFunction -> $DisplayFunction];

The approximate amount of fluid that flowed across the curve in this short time is measured by the area of the parallelogram defined by the two line segments shown above. 
Put in the vector 
       flowtime (Field[x[tt], y[tt]] . unitnormal[tt]) 
        unitnormal[tt]
for tt=(π/4), and flowtime = 0.4 as above:

Clear[unitnormal];
unitnormal[t_]:=(({y'[t],-x'[t]})/(Sqrt[((y'[t])^2)+((x'[t])^2)]));

Show[setup[tt], fluidbit[center[tt], tt, h], 
        fluidbit[center[tt] + flowtime Field[x[tt], y[tt]], tt, h], 
        Arrow[flowtime Field[x[tt], y[tt]] . unitnormal[tt] unitnormal[tt], 
          Tail -> {x[tt], y[tt]}], 
        PlotRange 
          -> {{x[tt] - 4 h, x[tt] + 4 h}, {y[tt] - 4 h, 
              y[tt] + 4 h}}, DisplayFunction -> $DisplayFunction];

Bingo!
The length of the new vector plotted above is 
       flowtime (Field[x[tt], y[tt]] .  unitnormal[tt]). 
Putting ds = length of the fluid segment, you can say that in this flowtime, approximately
       flowtime (Field[x[tt], y[tt]] .  unitnormal[tt]) ds
units of fluid flow across the segment of the curve in the above plot.
The flow goes with the normal {y'[tt],-x'[tt]} at this point because
       Field[x[tt], y[tt]] .  unittnormal[tt] > 0:

N[Field[x[tt], y[tt]] . unitnormal[tt]]

See what happens at another point on the curve:

tt = ((2 π)/3); Show[setup[tt], fluidbit[center[tt], tt, h], 
      fluidbit[center[tt] + flowtime Field[x[tt], y[tt]], tt, h], 
      Arrow[flowtime Field[x[tt], y[tt]] . unitnormal[tt] unitnormal[tt], 
        Tail -> {x[tt], y[tt]}], 
      PlotRange 
        -> {{x[tt] - 4 h, x[tt] + 4 h}, {y[tt] - 4 h, y[tt] + 4 h}}, 
      DisplayFunction -> $DisplayFunction];

Again, putting ds = length of the fluid segment, you can say that in this flowtime, approximately
       flowtime  (Field[x[tt], y[tt]] .  unittnormal[tt]) ds 
      
units of fluid flow across the curve in the above plot.
The flow is opposite the direction of the normal {y'[tt],-x'[tt]} at this point because
       Field[x[tt], y[tt]] .  unittnormal[tt] < 0:

N[Field[x[tt], y[tt]] . unitnormal[tt]]

B.1.a.i)

Explain why this tells you that the integral
       (∫_tlow^thigh) Field[x[t], y[t]].{y'[t],-x'[t]} dt:

tlow = 0; thigh = 2 π; NIntegrate[Field[x[t], y[t]].{y'[t],-x'[t]},{t, tlow, thigh}]

measures the net amount of fluid flowing across this curve per unit of flow time.

Fixing a particular t, you know that in a short flowtime approximately
              flowtime  (Field[x[t], y[t]]  .  unittnormal[t]) ds 
units of fluid flow across the small segment of the curve of length ds centered at {x[t], y[t]}. 
Because you integrate  (Sqrt[((x'[t])^( 2))+((y'[t])^( 2))]) to measure length on the curve, you know that 
       ds=(Sqrt[((x'[t])^( 2))+((y'[t])^( 2))]) dt. 
This tells you that, in a short flowtime, approximately 
       flowtime Field[x[t], y[t]]  .  unittnormal[t] (Sqrt[((x'[t])^( 2))+((y'[t])^( 2))]) dt
units of fluid flow across the a small segment of the curve of length ds centered at {x[t], y[t]}.
But 
       unitnormal[t]=(({y'[t] , -x'[t]})/(Sqrt[((x'[t])^( 2)) + ((y'[t])^( 2
                  ))])),
so 
       (Field[x[t], y[t]]· unittnormal[t])(Sqrt[((x'[t])^( 2))+((y'[t])^( 2))])
       =Field[x[t], y[t]]·{y'[t],-x'[t]}.
This tells you that, in a short flowtime, approximately
       flowtime Field[x[t], y[t]]·{y'[t],-x'[t]}dt
units of fluid flow across the small segment of the curve.
Now, cover the whole curve with non-overlapping little segments of length ds as above.  Adding the individual measurements together, you get the approximate flow-across measurement

       flowtime Sum[(Field[x[t], y[t]]·{y'[t],-x'[t]}dt),
		                     {t, tlow, thigh - dt,  dt}].
       
As dt closes in on 0, these approximate measurements close in on the exact measurement
       flowtime (∫_tlow^thigh) (Field[x[t], y[t]]·{y'[t],-x'[t]}) dt
of the net flow across the curve in the given flowtime.
To arrive at the measurement of the net flow across the whole curve per time unit, divide by flowtime to learn that   
       (∫_tlow^thigh) (Field[x[t], y[t]]·{y'[t],-x'[t]}) dt
measures the net flow over the curve per time unit.
If measurements are in gallons and seconds the calculation:

NIntegrate[Field[x[t], y[t]].{y'[t],-x'[t]},{t, 0, 2 π}]

tells you that the net flow of this vector field across the curve above is 0.628319 gallons per second.

B.1.a.ii)

Take another look at the integral
       (∫_tlow^thigh) (Field[x[t], y[t]]·{y'[t],-x'[t]}) dt
 for the vector field and the curve specified above:

NIntegrate[Field[x[t], y[t]].{y'[t],-x'[t]},{t, tlow, thigh}]

This tells you that the net flow of this vector field across this curve is about 0.63 fluid units per time unit.
Why does this also tell you that the net flow is from inside to outside?

Look at this plot of 
       Field[x[t], y[t]]·{y'[t],-x'[t]}
for tlow ≤ t ≤ thigh:

Plot[Field[x[t], y[t]].{y'[t],-x'[t]},{t, 0, 2 π},PlotStyle -> {{Thickness[0.01], Blue}},AxesLabel -> {"t", "Field.normal"}];

(∫_tlow^thigh) (Field[x[t], y[t]]·{y'[t],-x'[t]}) dt
        = area above  -  area below.
-> area above the t-axis = total flow of this vector field across this curve in the direction of the normals
       {y'[t],-x'[t]}.
-> area below the t-axis = total flow of this vector field across this curve opposite the direction of the normals
       {y'[t],-x'[t]}.
In the case above,    
       (∫_tlow^thigh) (Field[x[t], y[t]]·{y'[t],-x'[t]}) dt>0 :

NIntegrate[Field[x[t], y[t]].{y'[t],-x'[t]},{t, tlow, thigh}]

This tells you that the flow in the direction of the normals is greater than the flow against the normals.
Take a look at the normals:

Show[curveplot,Table[Arrow[{y'[t],-x'[t]},Tail -> {x[t], y[t]},VectorColor -> Red],{t, tlow, thigh, ((thigh - tlow)/8)}]];

The normals point out way from the curve.
The upshot:  The net flow of the given vector field across this curve is from inside to outside because  
       (∫_tlow^thigh)(Field[x[t], y[t]] . {y'[t],-x'[t]}) dt>0 :

NIntegrate[Field[x[t], y[t]].{y'[t],-x'[t]},{t, tlow, thigh}]

B.1.b.i)

Here's a new vector field:

\(Clear[Field, m, n, x, y]; 
m[x_, y_] = 2\ x\ y; 

    n[x_, y_] = x\^2 - y\^2; 

Field[x_, y_] = {m[x, y], n[x, y]}\)

Here's a new curve:

\(Clear[t]; 
{x[t_], y[t_]} = {Cos[t]\^3, Sin[t]\^3}; 

tlow = 0; 

    \(thigh = 2\ π; \)\)curveplot = 
      ParametricPlot[{x[t], y[t]}, {t, tlow, thigh}, 
        PlotStyle -> {{Thickness[0.01], Red}}, 
        AxesLabel -> {"x", "y"}];

Use the integral
       (∫_tlow^thigh) (Field[x[t], y[t]] . {y'[t],-x'[t]}) dt
to analyze the net flow of this vector field across this curve.

(∫_tlow^thigh)Field[x[t], y[t]].{y'[t],-x'[t]}\[DifferentialD]t

This tells you that the inside-to-outside flow across this curve exactly balances the outside-to-inside flow across the curve.
The net flow of this vector field across this curve is 0.

B.1.b.ii)

Here's another new vector field:

\(Clear[Field, m, n, x, y]; 
m[x_, y_] = x + y; 

    n[x_, y_] = x\^2 + y\^2; 

Field[x_, y_] = {m[x, y], n[x, y]}\)

Here's another new curve:

\(Clear[t]; 
    
{x[t_], 
        y[t_]} = {1, 0} + {Sin[π\ t] + 1\/5\ Cos[4\ π\ t], 
          Cos[π\ t] + 1\/8\ Sin[5\ π\ t]}; 
tlow = 0; 
thigh = 2; 

    
curveplot = 
      ParametricPlot[{x[t], y[t]}, {t, tlow, thigh}, 
        PlotStyle -> {{Thickness[0.01], Red}}, 
        AxesLabel -> {"x", "y"}]; \)

Use the integral
       (∫_tlow^thigh) (Field[x[t], y[t]] . {y'[t],-x'[t]}) dt
to help analyze the net flow of this vector field across this curve.

The parameterization of the curve involves squirrelly functions, so try NIntegrate:

NIntegrate[Field[x[t], y[t]].{y'[t],-x'[t]},{t, tlow, thigh},AccuracyGoal -> 2]

This tells you
       (∫_tlow^thigh) (Field[x[t], y[t]] . {y'[t],-x'[t]}) dt<0.
The net flow across this curve is in the opposite direction of the normals.
See which way the normals point:

scalefactor = 0.2; Show[curveplot,Table[Arrow[ {y'[t],-x'[t]},Tail -> {x[t], y[t]},ScaleFactor -> scalefactor,VectorColor -> Red],{t, tlow, thigh, ((thigh - tlow)/8)}]];

The normals point to the inside of the curve and the net flow is opposite to the direction of the these inward-pointing normals.  The result: The net flow of this vector field across this curve is from inside to outside. Math happens again.

B.2) Measuring flow along a curve with the integral
       (∫_tlow^thigh)(Field[x[t], y[t]] .{x'[t],y'[t]})dt

B.2.a)

Given a vector field Field[x, y] and a curve specified through parametric equations {x[t], y[t]} with tlow ≤ t ≤ thigh, you use the integral  
       (∫_tlow^thigh) Field[x[t], y[t]] . {y'[t],-x'[t]}dt 
to measure the flow of the field across the curve.
What do you measure when you calculate
       (∫_tlow^thigh) Field[x[t], y[t]] . {x'[t],y'[t]}dt?

{y'[t], -x'[t]} is a normal vector, and when you calculate
       (∫_tlow^thigh) Field[x[t], y[t]] . {y'[t],-x'[t]}dt,
you measure net flow across the curve.
Analogously, {x'[t],y'[t]} is a tangent vector, and when you calculate
       (∫_tlow^thigh) Field[x[t], y[t]] . {x'[t],y'[t]}dt,
you measure net flow ALONG the curve.

B.2.b)

Here's a vector field:

\(Clear[Field, m, n, x, y, t]; 
m[x_, y_] = y\ Sin[x]; 

    n[x_, y_] = \(-x\)\ Cos[y]; 

Field[x_, y_] = {m[x, y], n[x, y]}\)

And here is a curve C:

tlow = 0; \(thigh = 1; 

x[t_] = 6\ t\ \((1 - t)\); 

    y[t_] = 6\ t\^2\ Cos[\(π\ t\)\/2]; 


    curveplot = 
      ParametricPlot[{x[t], y[t]}, {t, 0, 1}, 
        PlotStyle -> {{Red, Thickness[0.01]}}, 
        AxesLabel -> {"x", "y"}, PlotRange -> All]; \)

Use the integral 
       (∫_tlow^thigh) Field[x[t], y[t]] . {x'[t],y'[t]}dt
to determine whether the net flow of Field[x, y] along C is clockwise or is counterclockwise.

Answer:

Make the flow-along-the-curve measurement
       (∫_tlow^thigh) Field[x[t], y[t]]·{x'[t],y'[t]}dt:

NIntegrate[Field[x[t], y[t]].{x'[t],y'[t]},{t, tlow, thigh}]

Negative.  This means that the flow of Field[x, y] along C is against the direction of the tangent vectors {x'[t],y'[t]} of this parameterization of C.
Take a look at some of these tangent vectors:

scalefactor = 0.3; tanvectors=Table[Arrow[ {x'[t],y'[t]},Tail -> {x[t], y[t]},VectorColor -> Red,ScaleFactor -> scalefactor],{t, tlow, thigh, ((thigh - tlow)/6)}];
Show[curveplot, tanvectors];

This curve is parameterized in the counterclockwise way.  Because 
       (∫_tlow^thigh) (Field[x[t], y[t]]·{x'[t],y'[t]})dt
turned out negative, this tells you that the flow of this field along this curve is clockwise.
Confirm with a plot of some of the tangential components of the field vectors on the curve:

Clear[tan, tancomp];
tan[t_]={x'[t],y'[t]};
tancomp[t_] = 
        Field[x[t], y[t]] . tan[t]/tan[t] . tan[t] tan[t];

Show[curveplot, 
        Table[Arrow[tancomp[t], Tail -> {x[t], y[t]}, 
            VectorColor -> Blue], {t, tlow, thigh, 
            ((thigh - tlow)/12)}]];

Yessiree-Bob. 
Net clockwise flow, just as the measurement predicted.  
Math continues to work.

B.3) Measurements by path integrals  
       (∫_( C)) m[x, y] dx  +  
        n[x, y] dy

B.3.a.i)

Here's some crazy looking notation:
       (∫_( C)) m[x, y] dx  +  
        n[x, y] dy .
Folks call this a path integral.
Just what is a path integral?

Answer:

A path integral needs the following ingredients:
->  It needs two functions m[x, y] and n[x, y].
->  It needs a curve C with a specified direction.

The resulting path integral written as by
       (∫_( C)) m[x, y] dx  +  
        n[x, y] dy.

The path integral
       (∫_( C)) m[x, y] dx  +  
        n[x, y] dy
is calculated by evaluating the old-fashioned integral 
       (∫_tlow^thigh)(m[x[t], y[t]]x'[t]+ n[x[t], y[t]]y'[t])dt
where {x[t], y[t]}, tlow ≤ t ≤ thigh is any parameterization of C that gives the curve the same direction as the specified direction of C. 
Look familiar?
When you work with closed curves (like deformed circles with no loops), folks all across our planet have agreed to specify the counterclockwise direction.  There is a nifty piece of notation to do this.
For closed curves C without loops,
       (Subscript[∳,  C]) 
          m[x, y] dx +  n[x, y] dy
means that the parameterization you use to evaluate the path integral is counterclockwise.

B.3.a.ii) Calculating a path integral

Calculate
       (Subscript[∳,  C]) 
          m[x, y] dx  +  n[x, y] dy
for the case in which 
       m[x, y] = y  -  x,
       n[x, y] = 2 x y
and C is the ellipse 
       (((((x  -  1)/3)))^2)+((((y/2)))^2)=1.

Enter the vector field and go with a counterclockwise parameterization of the ellipse:

\(Clear[x, y, m, n, t]; 
m[x_, y_] = y - x; 
\(n[x_, y_] = 2\ x\ y; 
    \)\)\({x[t_], y[t_]} = {1, 0} + {3\ Cos[t], 2\ Sin[t]}; 
tlow = 0; 

    thigh = 2\ π; 


    curveplot = 
      ParametricPlot[{x[t], y[t]}, {t, tlow, thigh}, 
        PlotStyle -> {{Thickness[0.01], Red}}, 
        AxesLabel -> {"x", "y"}]; \)

Check to be sure that the parameterization is counterclockwise:

Show[curveplot,Table[Arrow[{x'[t],y'[t]},Tail -> {x[t], y[t]},VectorColor -> Red],{t, tlow, thigh, ((thigh - tlow)/6)}]];

Good.
Here is the calculation of  
       (Subscript[∳,  C]) 
          m[x, y] dx  +  n[x, y] dy:

NIntegrate[m[x[t], y[t]] x'[t]+n[x[t], y[t]] y'[t],{t, tlow, thigh}]

Done.

B.3.b.i) Path integrals as a flow-along-the-curve measurement

Most folks say the path integral
       (Subscript[∳,  C]) 
          m[x, y] dx  +  n[x, y] dy
measures the flow of the vector field 
       Field[x, y] = {m[x, y], n[x, y]}
along a closed curve C.
They go on to say that if
       (Subscript[∳,  C]) 
            m[x, y] dx  +  n[x, y] dy > 0
        ,
then the net flow of 
       Field[x, y] = {m[x, y], n[x, y]}
along C is counterclockwise, but if
       (Subscript[∳,  C]) 
            m[x, y] dx  +  n[x, y] dy < 0
        ,
then the net flow of Field[x, y] = {m[x, y], n[x, y]} along C is clockwise.
Where do they get this idea?

Remember:
       (Subscript[∳,  C]) 
          m[x, y] dx  +  n[x, y] dy
demands a counterclockwise parameterization.
Also remember:
When a closed curve C is parameterized in the counterclockwise way with a parameterization {x[t], y[t]} with tlow ≤ t ≤ thigh, 
then the tangent vectors {x'[t],y'[t]} automatically point in the counterclockwise direction. 
When you measure the flow of a vector field   
       Field[x, y] = {m[x, y], n[x, y]}
along such a curve, you calculate

       (∫_tlow^thigh)(Field[x[t], y[t]]·{x'[t],y'[t]}) dt

       =(∫_tlow^thigh)({m[x[t], y[t]], n[x[t], y[t]]}·{x'[t],y'[t]})dt

       =(∫_tlow^thigh)(m[x[t], y[t]] x'[t]+ n[x[t], y[t]] y'[t])dt

        = 
        (Subscript[∳,  C]) 
            m[x, y] dx  +  n[x, y] dy.
The result:
       (Subscript[∳,  C]) 
          m[x, y] dx  +  n[x, y] dy
measures the flow of the vector field Field[x, y] = {m[x, y], n[x, y]} around a closed curve C.
Consequently, if
       (Subscript[∳,  C]) 
            m[x, y] dx  +  n[x, y] dy > 0
        ,
then the net flow of Field[x, y] = {m[x, y], n[x, y]} around C is counterclockwise, but if
       (Subscript[∳,  C]) 
            m[x, y] dx  +  n[x, y] dy < 0
        ,
then the net flow of Field[x, y] = {m[x, y], n[x, y]} around C is clockwise.

B.3.b.ii)

Calculate
       (Subscript[∳,  C]) 
          5 x y dx  + 
        ((x^3) +  (y^2)) dy
where C is the circle 
       (x^2) + (((y - 1))^2) = 4 
and interpret the result.

(Subscript[∳,  C]) 
          5 x y dx  + 
        ((x^3) +  (y^2)) dy
measures the net flow of the vector field
       Field[x, y] = {5 x y, (x^3) +  (y^2)}
along the circle.
Here are
-> a counterclockwise parameterization of C, and 
-> the calculation of
       (Subscript[∳,  C]) 
          5 x y dx  + 
        ((x^3) +  (y^2)) dy:

Clear[m, n, x, y, t];
tlow = 0;
thigh = 2 π;

{m[x_, y_], n[x_, y_]} = {5 x y, (x^3) + (y^2)};
{x[t_], y[t_]} = {0, 1} + 2 {Cos[t], Sin[t]};

NIntegrate[m[x[t], y[t]] x'[t]+n[x[t], y[t]] y'[t],{t, tlow, thigh}]

Big time positive.
This tells you that the net flow of the vector field
       Field[x, y] = {5 x y, (x^3) +  (y^2)}
along the circle is strongly counterclockwise.
Check it out with a plot if you don't believe it.

B.3.c.i) Path integrals as a flow-across-the-curve measurement

Most folks say the path integral
       (Subscript[∳,  C]) 
          -n[x, y] dx  +  
        m[x, y] dy
measures the flow of the vector field 
       Field[x, y] = {m[x, y], n[x, y]}
across a closed curve C.
They go on to say that if
       (Subscript[∳,  C]) 
            -n[x, y] dx  +  
          m[x, y] dy > 0,
then the net flow of Field[x, y] = {m[x, y], n[x, y]} across C is from inside to outside, but if
       (Subscript[∳,  C]) 
            -n[x, y] dx  +  
          m[x, y] dy < 0,
then the net flow of Field[x, y] = {m[x, y], n[x, y]} across C is from outside to inside. 
Where do they get this idea?

Remember:
       (Subscript[∳,  C]) 
          -n[x, y] dx  +  
        m[x, y] dy
demands a counterclockwise parameterization.
Also remember:
When a closed curve C is parameterized in the counterclockwise way with a parameterization 
       {x[t], y[t]} with tlow ≤ t ≤ thigh, 
then the normal vectors {y'[t],-x'[t]} automatically point out away from the inside to the outside of the curve. 
When you measure the flow of a vector field   
       Field[x, y] = {m[x, y], n[x, y]}
across such a curve, you calculate

       (∫_tlow^thigh)( Field[x[t], y[t]]·{y'[t],-x'[t]})dt

       =(∫_tlow^thigh){m[x[t], y[t]], n[x[t], y[t]]}·{y'[t],-x'[t]}dt

       =(∫_tlow^thigh)( m[x[t], y[t]] y'[t]- n[x[t], y[t]] x'[t])dt
 
        = 
        (Subscript[∳,  C]) 
            -n[x, y] dx  +  
          m[x, y] dy.
The upshot:
       (Subscript[∳,  C]) 
          -n[x, y] dx  +  
        m[x, y] dy
measures the flow of the vector field 
       Field[x, y]  =  {m[x, y], n[x, y]}
across C.
To wrap it up: If
       (Subscript[∳,  C]) 
            -n[x, y] dx  +  
          m[x, y] dy > 0,
then the net flow of Field[x, y] = {m[x, y], n[x, y]} across C is from inside to outside, but if
       (Subscript[∳,  C]) 
            -n[x, y] dx  +  
          m[x, y] dy  <  0,
then the net flow of Field[x, y] = {m[x, y], n[x, y]} across C is from outside to inside.

B.3.c.ii)

Calculate
       (Subscript[∳,  C]) 
          (E^y) dx - (E^x) dy 
where C is the circle 
       (x^2) + (((y - 0.5))^2) = 0.7 
and give two interpretations of the measurement.

Here are
-> a counterclockwise parameterization of C, and 
-> the calculation of
       (Subscript[∳,  C]) 
          (E^y) dx - (E^x) dy :

Clear[m, n, x, y, t];
tlow = 0;
thigh = 2 π;

{m[x_, y_], n[x_, y_]} = {(E^y), -(E^x)};
{x[t_], y[t_]} = {0, 0.5} + (Sqrt[0.7]) {Cos[t], Sin[t]};

NIntegrate[m[x[t], y[t]] x'[t]+n[x[t], y[t]] y'[t],{t, tlow, thigh}]

Negative.
->  Flow-along measurement interpretation:
       (Subscript[∳,  C]) 
          m[x, y] dx  +  n[x, y] dy
 measures the net flow of 
       Field[x, y] = {m[x, y], n[x, y]} along C.
The path integral calculated here was  
       (Subscript[∳,  C]) 
            (E^y) dx - (E^x) dy < 0
So:
The net flow of the vector field
       Field[x, y] = {(E^y), -(E^x)} 
along the circle is clockwise.
->  Flow-across measurement interpretation:
       (Subscript[∳,  C])-n[x, y] 
            dx  +  m[x, y] dy
 measures the net flow of 
       Field[x, y] = {m[x, y], n[x, y]} across C.
The path integral calculated here was  
       (Subscript[∳,  C]) 
            (E^y) dx - (E^x) dy < 0
So:
The net flow of the vector field
       Field[x, y] = {-(E^x), - (E^y)}
across the circle is is from outside to inside.

B.4) Directed curves; path integrals 
       (∫_( C)) m[x, y] dx  +  
        n[x, y] dy,     
       path independence, and gradient fields

B.4.a)

Lots of folks say that a parameterization gives a curve a direction.
What do they mean by this?

Answer:

The direction your parameterization goes specifies a direction for the curve.
Here's a curve {x[t], y[t]} with a few scaled tangent vectors {x'[t],y'[t]}:

\(Clear[x, y, t, direction]; 
tlow = 0.25; 
thigh = 1.25; 

    
{x[t_], y[t_]} = {1 + 3\ Sin[2\ t]\^2\ Cos[t], t\ E\^t}; 


    curveplot1 = 
      ParametricPlot[{x[t], y[t]}, {t, tlow, thigh}, 
        PlotStyle -> {{Red, Thickness[0.01]}}, 
        DisplayFunction -> Identity, 
        Epilog -> {Text["start", {x[tlow], y[tlow]}], 
            Text["end", {x[thigh], y[thigh]}]}]; 

scalefactor = 0.25; 
    
\(jump = \(thigh - tlow\)\/6; \)\)tanvectors=Table[Arrow[{x'[t],y'[t]},Tail -> {x[t], y[t]},VectorColor -> Red,ScaleFactor -> scalefactor ],{t, tlow, thigh - jump, jump}];

direction1 = 
        Show[curveplot1, tanvectors, AxesOrigin -> {0, 0}, 
          AxesLabel -> {"x", "y"}, 
          PlotRange -> {{0, 5}, {0, 5}}, 
          PlotLabel -> "Direction 1", 
          DisplayFunction -> $DisplayFunction];

You can plot the same physical curve the reverse direction by changing the parameterization:

\(Clear[xx, yy, t]; 
a = tlow; 
b = thigh; 

    
{xx[t_], yy[t_]} = {x[b - t\ \((b - a)\)], y[b - t\ \((b - a)\)]}; 


    curveplot2 = 
      ParametricPlot[{xx[t], yy[t]}, {t, 0, 1}, 
        PlotStyle -> {{Red, Thickness[0.01]}}, 
        DisplayFunction -> Identity, 
        Epilog -> {Text["start", {xx[0], yy[0]}], 
            Text["end", {xx[1], yy[1]}]}]; 

scalefactor = 0.25; 

    \(jump = \(1 + 0\)\/5; \)\)tanvectors=Table[Arrow[ {xx'[t],yy'[t]},Tail -> {xx[t], yy[t]},VectorColor -> Red,ScaleFactor -> scalefactor],{t, 0, 1 - jump, jump}];

direction2 = 
        Show[curveplot2, tanvectors, AxesOrigin -> {0, 0}, 
          AxesLabel -> {"x", "y"}, 
          PlotRange -> {{0, 5}, {0, 5}}, 
          PlotLabel -> "Direction 2", 
          DisplayFunction -> $DisplayFunction];

The curve is physically the same curve, but this new parameterization directs it to run from high to low.
Compare:

Show[GraphicsArray[{direction1, direction2}]];

If the curve C is closed (like a deformed circle) and has no loops, then there is no natural start or end.  Your parametrization gives a start, an end, and a clockwise or counterclockwise direction.  It's all up to you.  
Here is a closed curve parameterized in the counterclockwise direction with the start point the same as the end point:

\(Clear[x, y, t, direction]; 
tlow = 0; 
thigh = 2\ π; 

    
{x[t_], y[t_]} = {\((1 + Sin[t]\^2)\)\ Cos[t], 
        \((0.5 + 2\ Cos[t]\^2)\)\ Sin[t]}; 


    curveplot1 = 
      ParametricPlot[{x[t], y[t]}, {t, tlow, thigh}, 
        PlotStyle -> {{Red, Thickness[0.01]}}, 
        DisplayFunction -> Identity, 
        Epilog -> {Text["start", {x[tlow], y[tlow]}, {0, \(-2\)}], 
            Text["end", {x[thigh], y[thigh]}, {0, 2}]}]; 


    scalefactor = 0.25; 
\(jump = \(thigh - tlow\)\/8; \)\)tanvectors=Table[Arrow[ {x'[t],y'[t]},Tail -> {x[t], y[t]},VectorColor -> Red, ScaleFactor -> scalefactor],{t, tlow, thigh - jump, jump}];

counterclockwise = 
        Show[curveplot1, tanvectors, AxesOrigin -> {0, 0}, 
          AxesLabel -> {"x", "y"}, 
          PlotLabel -> "Counterclockwise", PlotRange -> All, 
          DisplayFunction -> $DisplayFunction];

Here is the same curve with a clockwise parameterization with the start point the same as the end point:

Clear[xx, yy, t];
{xx[t_], yy[t_]} = {x[thigh - t], y[thigh - t]};

curveplot2 = 
        ParametricPlot[{xx[t], yy[t]}, {t, tlow, thigh}, 
          PlotStyle -> {{Red, Thickness[0.01]}}, 
          DisplayFunction -> Identity, 
          Epilog -> {
              Text["start", {xx[tlow], yy[tlow]}, {0, -2}], 
              Text["end", {xx[thigh], yy[thigh]}, {0, 2}]}];

scalefactor = 0.25;
jump = ((thigh - tlow)/8);
tanvectors=Table[Arrow[ {xx'[t],yy'[t]},Tail -> {xx[t], yy[t]},VectorColor -> Red,ScaleFactor -> scalefactor],{t, tlow, thigh - jump, jump}];

clockwise = 
          Show[curveplot2, tanvectors, AxesOrigin -> {0, 0}, 
            AxesLabel -> {"x", "y"}, 
            PlotLabel -> "Clockwise", PlotRange -> All, 
            DisplayFunction -> $DisplayFunction];

For closed curves without loops, the clockwise and counterclockwise directions are the only choices you have.

B.4.b)

Calculate
       (∫_( C)) x (E^(x y)) dx + 
        y (E^(x y)) dy  
where C is the part of the parabola 
       y = (x^2)
starting at {0, 0} and ending at {2, 4}. 
Interpret the meaning of the result.

Here's everything you need:

\(Clear[m, n, x, y, t]; 
tlow = 0; 
thigh = 2; 


    m[x_, y_] = x\ E\^\(x\ y\); 
n[x_, y_] = y\ E\^\(x\ y\); 

    
{x[t_], y[t_]} = {t, t\^2}; 


    curveplot = 
      ParametricPlot[{x[t], y[t]}, {t, tlow, thigh}, 
        PlotStyle -> {{Red, Thickness[0.01]}}, 
        AxesLabel -> {"x", "y"}, 
        PlotLabel -> "C and its direction", 
        Epilog -> {
            Text["start", {x[tlow], y[tlow]}, {\(-2\), \(-2\)}], 
            Text["end", {x[thigh], y[thigh]}, {2, 2}]}]; \)

Yep, the curve C runs on the parabola y = (x^2) and starts at {0, 0} and ends at {2, 4}.
Here comes the calculation of (∫_( C)) x (E^(x y)) dx + 
        y (E^(x y)) dy:

NIntegrate[m[x[t], y[t]] x'[t]+n[x[t], y[t]] y'[t],{t, tlow, thigh}]

Humongously positive.
-> Flow-along interpretation:
       (∫_( C)) x (E^(x y)) dx + 
        y (E^(x y)) dy 
measures the net flow of the vector field 
       Field[x, y] = {x (E^(x y)), y (E^(x y))}
along C. The net flow of this vector field is strongly in the direction of the parameterization of the curve (from low to high).
-> Flow-across interpretation:
       (∫_( C)) x (E^(x y)) dx + 
        y (E^(x y)) dy 
measures the net flow of the vector field 
       Field[x, y] = {y (E^(x y)), -x (E^(x y))}
across C. The net flow of this vector field across C is strongly in the direction of the normals {y'[t],-x'[t]}. These normals point to the right as you advance along the curve in the direction of the parameterization, so the net flow of the vector field 
       Field[x, y] = {y (E^(x y)), -x (E^(x y))}
across C is from above C to below C.

B.4.c.i) Fundamental formula for path integrals of gradient fields

Here's a cleared gradient field:

\(Clear[f, x, y, m, n, gradf, Field]; 

    gradf[x_, y_] = {D[f[x, y], \ x], D[f[x, y], \ y]}; 
    
{m[x_, y_], n[x_, y_]} = gradf[x, y]; 


    Field[x_, y_] = {m[x, y], n[x, y]}\)

Here's Mathematica's calculation of 
       (∫_( C)) m[x, y] dx  +  
        n[x, y] dy
for a cleared parameterization of a curve C that starts at {x[tlow], y[tlow]} and ends at {x[thigh], y[thigh]}:

Clear[t];
(∫_tlow^thigh)(m[x[t], y[t]] x'[t] + n[x[t], y[t]] y'[t])\[DifferentialD]t

Explain where the answer comes from.

Answer:

Put:

\(Clear[g]; 
g[t_] = f[x[t], y[t]]\)

Compare:

D[g[t],  t]==m[x[t], y[t]] x'[t]+n[x[t], y[t]] y'[t]

This tells you 
       g'[t]=m[x[t], y[t]] x'[t]+ n[x[t], y[t]] y'[t].
The fundamental formula of calculus tells you
       f[x[thigh], y[thigh]] -  f[x[tlow], y[tlow]]
       
        =  g[thigh] -  g[tlow]
       
       =(∫_tlow^thigh) g'[t]dt

       =(∫_tlow^thigh) (m[x[t], y[t]] x'[t]+ n[x[t], y[t]] y'[t])dt 

        = 
        (∫_( C)) m[x, y] dx +  
          n[x, y] dy. 
So 
       (∫_( C)) m[x, y] dx +  
        n[x, y] dy 
        = f[x[thigh], y[thigh]] -  f[x[tlow], y[tlow]]
in the case that {m[x, y], n[x, y]} = ∇f[x, y].
The explanation is over.

B.4.c.ii) Path independence for gradient fields

Now you know why you are guaranteed that
       f[(Subscript[x, 1]), (Subscript[y, 1])] -  f[(Subscript[x, 0]), (Subscript[y, 0])] = 
        (∫_( C)) m[x, y] dx  +  
          n[x, y] dy
for any curve C starting at {(Subscript[x, 0]), (Subscript[y, 0])} and ending at {(Subscript[x, 1]), (Subscript[y, 1])} 
provided 
       {m[x, y], n[x, y]} = ∇f[x, y]
for a function f[x, y].
What calculational advantage do you get from this?
What theoretical advantage do you get from this?

-> Your calculational advantage:
Here's a gradient field:

\(Clear[f, x, y, gradf, m, n]; 
f[x_, y_] = Sin[π\ x\ y]; 


    gradf[x_, y_] = {D[f[x, y], \ x], D[f[x, y], \ y]}; 
    
{m[x_, y_], n[x_, y_]} = gradf[x, y]\)

Because {m[x, y], n[x, y]} = ∇f[x, y], you are guaranteed that if C is any curve running from {0, 0} to {1, (5/2)}, then 
       (∫_( C)) m[x, y] dx  +  
        n[x, y] dy
is given by:

f[1, (5/2)] - f[0, 0]

Your calculational advantage is that you don't have to set up any parameterizations to calculate the path integral  
       (∫_( C)) m[x, y] dx  +  
        n[x, y] dy.
-> Your theoretical advantage:
When you know that 
       {m[x, y], n[x, y]} = ∇f[x, y], 
then you know that
       (∫_( C)) m[x, y] dx  +  
        n[x, y] dy
DOES NOT DEPEND ON THE ROUTE OF THE PATH C takes from its start to its end. In fact,the value of
       (∫_( C)) m[x, y] dx  +  
        n[x, y] dy
depends ONLY on the starting point and the ending point of C.

B.4.c.iii) The net flow of a gradient field along any closed curve is 0

If Field[x, y] = ∇f[x, y] for a function f[x, y], then how do you know that the flow of Field[x, y] along any closed curve is 0?

Put 
       Field[x, y] = {m[x, y], n[x, y]} = ∇f[x, y].
You are guaranteed that
       f[(Subscript[x, 1]), (Subscript[y, 1])] -  f[(Subscript[x, 0]), (Subscript[y, 0])] = 
        (∫_( C)) m[x, y] dx  +  
          n[x, y] dy
for any curve C starting at {(Subscript[x, 0]), (Subscript[y, 0])} and ending at {(Subscript[x, 1]), (Subscript[y, 1])}.
But for a closed curve C (like a deformed circle) , you know that
       {(Subscript[x, 0]), (Subscript[y, 0])} = {(Subscript[x, 1]), (Subscript[y, 1])}.
So
       (Subscript[∳,  C]) 
          m[x, y] dx  +  n[x, y] dy

        = f[(Subscript[x, 1]), (Subscript[y, 1])] -  f[(Subscript[x, 0]), (Subscript[y, 0])]

        = f[(Subscript[x, 0]), (Subscript[y, 0])] -  f[(Subscript[x, 0]), (Subscript[y, 0])] = 0
in the case that C is a closed curve.
That's all there is to it.
Try it out for {m[x, y], n[x, y]} = ∇f[x, y] with 
       f[x, y] = (x^4) (y^2),
and with C the circle of radius 0.5 centered at {0, 0}:

\(Clear[f, x, y, m, n, gradf, Field, t]; 
f[x_, y_] = x\^4\ y\^2; 


    gradf[x_, y_] = {D[f[x, y], \ x], D[f[x, y], \ y]}; 
    
{m[x_, y_], n[x_, y_]} = gradf[x, y]; 


    Field[x_, y_] = {m[x, y], n[x, y]}; 
\(tlow = 0; \)\)thigh = 2 π;

{x[t_], y[t_]} = 0.5 {Cos[t], Sin[t]};

(∫_tlow^thigh)(m[x[t], y[t]] x'[t]+n[x[t], y[t]] y'[t])\[DifferentialD]t

Just as theory predicted.