Jim W. Kennington/2020-03-15T00:00:00-05:00Algebra Ladder2020-03-15T00:00:00-05:002020-03-15T00:00:00-05:00Jim Kenningtontag:None,2020-03-15:/blog/algebra-ladder/<p>I first encountered a diagram of algebraic structures at the end of Jeevanjee's second chapter,
"Vector Spaces", which elegantly summarizes the high-level differences in structure between sets,
vector spaces, and inner product spaces. </p>
<p><a href='#jeevanjeeIntroductionTensorsGroup2015' id='ref-jeevanjeeIntroductionTensorsGroup2015-1'>Jeevanjee (2015)</a>
This diagram was immensely helpful to me, in that it helped show the relationships between …</p><p>I first encountered a diagram of algebraic structures at the end of Jeevanjee's second chapter,
"Vector Spaces", which elegantly summarizes the high-level differences in structure between sets,
vector spaces, and inner product spaces. </p>
<p><a href='#jeevanjeeIntroductionTensorsGroup2015' id='ref-jeevanjeeIntroductionTensorsGroup2015-1'>Jeevanjee (2015)</a>
This diagram was immensely helpful to me, in that it helped show the relationships between various
commonly used objects in mathematical physics. As I've encountered new structures, I've attempted
to augment this map along two dimensions: a <em>structure</em> dimension that aims to measure the number
of attributes an algebraic object has, and a <em>specificity</em> dimension which measures the amount
of constraints placed on each attribute. </p>
<p>For instance, a Magma has more structure than a set, because a new attribute - a binary operator - has
been added. A group, though, is roughly similar in structure to a magma, but has more properties of
the binary operator specified, such as associativity, inverses, and identity, which make it more
specific (and the magma more general). <a href='#romanAdvancedLinearAlgebra2007' id='ref-romanAdvancedLinearAlgebra2007-1'>Roman (2007)</a> </p>
<p><img alt="Algebra Ladder" src="/images/algebra-ladder-small.png" />
Figure 1. Relationship of various algebraic structures. <a href="/images/algebra-ladder.png">Larger image</a></p>
<p>The diagram above aims to show how an algebra is constructed from a set, though admittedly omits
several algebraic structures along the way. I've attempted to include the most primary objects used or
seen in mathematical physics. I should also note, this diagram is intended as a quick-reference, and
isn't a substitute for opening Hungerford! <a href='#hungerfordAlgebra2003' id='ref-hungerfordAlgebra2003-1'>Hungerford (2003)</a></p><hr>
<h3>Bibliography</h3>
<p id='hungerfordAlgebra2003'>Thomas W. Hungerford.
<em>Algebra</em>.
Number 73 in Graduate Texts in Mathematics.
<span class="bibtex-protected">Springer</span>, <span class="bibtex-protected">New York</span>, corr. 8th print edition, 2003.
ISBN 978-0-387-90518-1 978-3-540-90518-9. <a class="cite-backref" href="#ref-hungerfordAlgebra2003-1" title="Jump back to reference 1">↩</a></p>
<p id='jeevanjeeIntroductionTensorsGroup2015'>Nadir Jeevanjee.
<em>An Introduction to Tensors and Group Theory for Physicists</em>.
<span class="bibtex-protected">Springer Science+Business Media</span>, <span class="bibtex-protected">New York, NY</span>, 2015.
ISBN 978-3-319-14793-2. <a class="cite-backref" href="#ref-jeevanjeeIntroductionTensorsGroup2015-1" title="Jump back to reference 1">↩</a></p>
<p id='romanAdvancedLinearAlgebra2007'>Steven Roman.
<em>Advanced Linear Algebra</em>.
Number 135 in Graduate Texts in Mathematics.
<span class="bibtex-protected">Springer</span>, <span class="bibtex-protected">New York</span>, 3rd ed edition, 2007.
ISBN 978-0-387-72828-5. <a class="cite-backref" href="#ref-romanAdvancedLinearAlgebra2007-1" title="Jump back to reference 1">↩</a></p>
Loading Gravitational Wave Data with PyCBC2019-10-12T00:00:00-05:002019-10-12T00:00:00-05:00Jim Kenningtontag:None,2019-10-12:/blog/loading-gravitational-wave-data-with-pycbc/<p>This post is the first in a series of in-depth examples for analyzing gravitational wave data in Python,
using the PyCBC package. There is also a notebook-version of this post, available <a href="https://github.com/JWKennington/pycbc-examples">here</a>,
in a repo of PyCBC examples.</p>
<h2>Motivation</h2>
<p>In order to analyze observed gravitational waves, we must first find …</p><p>This post is the first in a series of in-depth examples for analyzing gravitational wave data in Python,
using the PyCBC package. There is also a notebook-version of this post, available <a href="https://github.com/JWKennington/pycbc-examples">here</a>,
in a repo of PyCBC examples.</p>
<h2>Motivation</h2>
<p>In order to analyze observed gravitational waves, we must first find the data containing the signal. This
example shows how to explore the Catalog of observed mergers available via the Gravitational Wave Open
Science Center (GWOSC). Though this example focuses on the Python API, the list of available mergers can also
be found on the web at the following <a href="https://www.gw-openscience.org/catalog/GWTC-1-confident/html/">url</a>.</p>
<p style="background: #e6e6e6; border-radius: 10px; padding: 10px">
<i><b>Developer Note:</b></i><br>
The below example also uses the <a href="https://github.com/JWKennington/gravtools">gravtools</a> package, which
is just a small collection of convenience functions and utilities.
</p>
<div class="highlight"><pre><span></span><span class="o">>>></span> <span class="kn">from</span> <span class="nn">pycbc</span> <span class="kn">import</span> <span class="n">catalog</span><span class="p">,</span> <span class="n">frame</span>
<span class="o">>>></span> <span class="kn">from</span> <span class="nn">gravtools</span> <span class="kn">import</span> <span class="n">MergerParameters</span><span class="p">,</span> <span class="n">Observatory</span><span class="p">,</span> <span class="n">merger</span><span class="p">,</span> <span class="n">time</span>
</pre></div>
<p><br></p>
<h2>Exploring the Catalog</h2>
<p>A common structure for grouping astonomical data, a Catalog is a sensible concept for a programmatic API.
The PyCBC package has taken this approach, which is shown below using the <code>Catalog</code> class.</p>
<h3>The <code>Catalog</code> Class</h3>
<p>The PyCBC Catalog class is capable of using the GWOSC data api to see essentially the same information
contained in the link above (albeit through JSON instead of HTML). Under the hood, PyCBC relies on AstroPy
data-access file-download utilities.</p>
<p>We can create a catalog simply by creating an instance of the <code>Catalog</code> class, and specifying a data source.
In this case we specify <code>'gwtc-1'</code> which refers to the Gravitational-Wave Transient Catalog 1. This catalog
consists of compact binary mergers observed in the O1 and O2 runs, and is also the default catalog (so you don't
need to specify it, though we do for clarity).</p>
<div class="highlight"><pre><span></span><span class="o">>>></span> <span class="n">cat</span> <span class="o">=</span> <span class="n">catalog</span><span class="o">.</span><span class="n">Catalog</span><span class="p">(</span><span class="n">source</span><span class="o">=</span><span class="s1">'gwtc-1'</span><span class="p">)</span>
</pre></div>
<p><br></p>
<h3>Where are the <code>Merger</code>s stored?</h3>
<p>The Catalog class is an iterable with respect to the names of the mergers in the catalog, so you can pick your favorite
technique to iterate over the available merger names (we use the list coercion function below).</p>
<div class="highlight"><pre><span></span><span class="o">>>></span> <span class="c1"># Get names of mergers in catalog </span>
<span class="o">>>></span> <span class="n">merger_names</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="n">cat</span><span class="p">)</span> <span class="c1"># Catalog class is iterable, any collection coercion will suffice</span>
<span class="o">>>></span> <span class="n">merger_names</span><span class="p">[:</span><span class="mi">3</span><span class="p">]</span>
<span class="p">[</span><span class="s1">'GW150914'</span><span class="p">,</span> <span class="s1">'GW151012'</span><span class="p">,</span> <span class="s1">'GW151226'</span><span class="p">]</span>
</pre></div>
<p><br></p>
<p>The Merger data associated to the name is stored in the <code>mergers</code> attribute of the <code>Catalog</code> instance, which
is a dictionary keyed by the name of the merger (which we examined above). </p>
<h3>Basic Merger Properties</h3>
<p>The <code>Merger</code> object retrieved from the Catalog contains all the estimated parameters of the waveform. Each
attribute may be accessed directly, but the preferred way is through the "median1d" method of the Merger class.
Keep in mind that these parameters are in the <em>source</em> frame, not the <em>detector</em> frame.</p>
<p style="background: #e6e6e6; border-radius: 10px; padding: 10px">
<i><b>Developer Note:</b></i><br>
Unfortunately, the merger-parameter attributes of the Merger instance are not inspectable in a code
editor due the way they are set during instantiation (using the setattr function). The
<i>gravtools.MergerParameters</i> enumeration contains all the relevant parameter names,
and _is_ inspectable, so we use it below.
</p>
<div class="highlight"><pre><span></span><span class="o">>>></span> <span class="n">m</span> <span class="o">=</span> <span class="n">cat</span><span class="o">.</span><span class="n">mergers</span><span class="p">[</span><span class="s1">'GW150914'</span><span class="p">]</span>
<span class="o">>>></span> <span class="c1"># convenient summary string from gravtools</span>
<span class="o">>>></span> <span class="n">merger</span><span class="o">.</span><span class="n">summary</span><span class="p">(</span><span class="n">m</span><span class="p">)</span>
<span class="s1">'Merger[GW150914](Mass1=35.6, Mass2=30.6, FinalSpin=0.69)'</span>
<span class="o">>>></span> <span class="c1"># Log the names of the mergers in the catalog</span>
<span class="o">>>></span> <span class="k">print</span><span class="p">(</span><span class="s1">'Mergers in catalog:'</span><span class="p">)</span>
<span class="o">>>></span> <span class="k">for</span> <span class="n">name</span> <span class="ow">in</span> <span class="n">merger_names</span><span class="p">:</span>
<span class="n">m</span> <span class="o">=</span> <span class="n">cat</span><span class="o">.</span><span class="n">mergers</span><span class="p">[</span><span class="n">name</span><span class="p">]</span> <span class="c1"># load the Merger object by name</span>
<span class="c1"># the step above can also be done by instantiating a Merger object directly, e.g. catalog.Merger('GW150914')</span>
<span class="c1"># Print some merger info by accessing parameters through the "median1d" method</span>
<span class="k">print</span><span class="p">(</span><span class="s1">' {}: M1={:2.0f} M2={:2.0f} z={:2.2f}'</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">name</span><span class="p">,</span>
<span class="n">m</span><span class="o">.</span><span class="n">median1d</span><span class="p">(</span><span class="n">MergerParameters</span><span class="o">.</span><span class="n">Mass1</span><span class="p">),</span> <span class="c1"># m.mass1</span>
<span class="n">m</span><span class="o">.</span><span class="n">median1d</span><span class="p">(</span><span class="n">MergerParameters</span><span class="o">.</span><span class="n">Mass2</span><span class="p">),</span> <span class="c1"># m.mass2</span>
<span class="n">m</span><span class="o">.</span><span class="n">median1d</span><span class="p">(</span><span class="n">MergerParameters</span><span class="o">.</span><span class="n">Redshift</span><span class="p">)))</span> <span class="c1"># m.redshift</span>
<span class="n">Mergers</span> <span class="ow">in</span> <span class="n">catalog</span><span class="p">:</span>
<span class="n">GW150914</span><span class="p">:</span> <span class="n">M1</span><span class="o">=</span><span class="mi">36</span> <span class="n">M2</span><span class="o">=</span><span class="mi">31</span> <span class="n">z</span><span class="o">=</span><span class="mf">0.09</span>
<span class="n">GW151012</span><span class="p">:</span> <span class="n">M1</span><span class="o">=</span><span class="mi">23</span> <span class="n">M2</span><span class="o">=</span><span class="mi">14</span> <span class="n">z</span><span class="o">=</span><span class="mf">0.21</span>
<span class="n">GW151226</span><span class="p">:</span> <span class="n">M1</span><span class="o">=</span><span class="mi">14</span> <span class="n">M2</span><span class="o">=</span> <span class="mi">8</span> <span class="n">z</span><span class="o">=</span><span class="mf">0.09</span>
<span class="n">GW170104</span><span class="p">:</span> <span class="n">M1</span><span class="o">=</span><span class="mi">31</span> <span class="n">M2</span><span class="o">=</span><span class="mi">20</span> <span class="n">z</span><span class="o">=</span><span class="mf">0.19</span>
<span class="n">GW170608</span><span class="p">:</span> <span class="n">M1</span><span class="o">=</span><span class="mi">11</span> <span class="n">M2</span><span class="o">=</span> <span class="mi">8</span> <span class="n">z</span><span class="o">=</span><span class="mf">0.07</span>
<span class="n">GW170729</span><span class="p">:</span> <span class="n">M1</span><span class="o">=</span><span class="mi">51</span> <span class="n">M2</span><span class="o">=</span><span class="mi">34</span> <span class="n">z</span><span class="o">=</span><span class="mf">0.48</span>
<span class="n">GW170809</span><span class="p">:</span> <span class="n">M1</span><span class="o">=</span><span class="mi">35</span> <span class="n">M2</span><span class="o">=</span><span class="mi">24</span> <span class="n">z</span><span class="o">=</span><span class="mf">0.20</span>
<span class="n">GW170814</span><span class="p">:</span> <span class="n">M1</span><span class="o">=</span><span class="mi">31</span> <span class="n">M2</span><span class="o">=</span><span class="mi">25</span> <span class="n">z</span><span class="o">=</span><span class="mf">0.12</span>
<span class="n">GW170817</span><span class="p">:</span> <span class="n">M1</span><span class="o">=</span> <span class="mi">1</span> <span class="n">M2</span><span class="o">=</span> <span class="mi">1</span> <span class="n">z</span><span class="o">=</span><span class="mf">0.01</span>
<span class="n">GW170818</span><span class="p">:</span> <span class="n">M1</span><span class="o">=</span><span class="mi">36</span> <span class="n">M2</span><span class="o">=</span><span class="mi">27</span> <span class="n">z</span><span class="o">=</span><span class="mf">0.20</span>
<span class="n">GW170823</span><span class="p">:</span> <span class="n">M1</span><span class="o">=</span><span class="mi">40</span> <span class="n">M2</span><span class="o">=</span><span class="mi">29</span> <span class="n">z</span><span class="o">=</span><span class="mf">0.34</span>
</pre></div>
<p><br></p>
<h2>Merger Strain</h2>
<p>Though a Merger object loads several scalar parameters once instantiated, it does not automatically load the
timeseries of strain data (for efficiency of the API). It is possible, however, and quite easy to load the
strain timeseries around the event. The below code shows how to load the waveform data. We begin by choosing a
specific merger from the catalog.</p>
<div class="highlight"><pre><span></span><span class="o">>>></span> <span class="c1"># Pick a merger from the catalog</span>
<span class="o">>>></span> <span class="n">m</span> <span class="o">=</span> <span class="n">cat</span><span class="o">.</span><span class="n">mergers</span><span class="p">[</span><span class="s1">'GW170823'</span><span class="p">]</span>
</pre></div>
<p><br></p>
<h3>The <code>TimeSeries</code> Class</h3>
<p>The time series data containing the merger waveform is returned as an instance of the <code>TimeSeries</code> class. Below,
we show how to load the strain data, as well as how to do some useful manipulations.</p>
<p style="background: #e6e6e6; border-radius: 10px; padding: 10px">
<i><b>Developer Note:</b></i><br>
The <i>pycbc.TimeSeries</i> class, which contains the merger strain data (as mentioned above), is a thin wrapper
around a numpy or pycuda array supporting many of the common array interface features, such as slicing. There is
also additional metadata, including the GPS starting and ending time of the waveform, as well as the time
interval between adjacent values in the array.
</p>
<div class="highlight"><pre><span></span><span class="c1"># Query the strain timeseries for the merger</span>
<span class="o">>>></span> <span class="n">ts</span> <span class="o">=</span> <span class="n">m</span><span class="o">.</span><span class="n">strain</span><span class="p">(</span><span class="n">ifo</span><span class="o">=</span><span class="n">Observatory</span><span class="o">.</span><span class="n">LIGOHanford</span><span class="p">)</span> <span class="c1"># the "ifo" argument refers to the observatory that recorded the strain</span>
<span class="o">>>></span> <span class="c1"># Print the boundaries of the timeseries</span>
<span class="o">>>></span> <span class="k">print</span><span class="p">(</span><span class="s1">'Duration={:.0f}s Interval={:.1e}s Start={} End={}'</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">ts</span><span class="o">.</span><span class="n">duration</span><span class="p">,</span> <span class="n">ts</span><span class="o">.</span><span class="n">delta_t</span><span class="p">,</span>
<span class="n">time</span><span class="o">.</span><span class="n">gps_to_datetime</span><span class="p">(</span><span class="n">ts</span><span class="o">.</span><span class="n">start_time</span><span class="p">),</span>
<span class="n">time</span><span class="o">.</span><span class="n">gps_to_datetime</span><span class="p">(</span><span class="n">ts</span><span class="o">.</span><span class="n">end_time</span><span class="p">)))</span>
<span class="o">>>></span> <span class="c1"># Print the size of the underlying array</span>
<span class="o">>>></span> <span class="k">print</span><span class="p">(</span><span class="s1">'Array Size: {:,d}'</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">ts</span><span class="p">)))</span>
<span class="o">>>></span> <span class="c1"># Supports Slicing</span>
<span class="o">>>></span> <span class="k">print</span><span class="p">(</span><span class="s1">'Array Size: {:,d}'</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">ts</span><span class="p">[:</span><span class="mi">100</span><span class="p">])))</span>
<span class="n">Duration</span><span class="o">=</span><span class="mi">32</span><span class="n">s</span> <span class="n">Interval</span><span class="o">=</span><span class="mf">2.4e-04</span><span class="n">s</span> <span class="n">Start</span><span class="o">=</span><span class="mi">2017</span><span class="o">-</span><span class="mi">08</span><span class="o">-</span><span class="mi">23</span> <span class="mi">13</span><span class="p">:</span><span class="mi">14</span><span class="p">:</span><span class="mi">20</span> <span class="n">End</span><span class="o">=</span><span class="mi">2017</span><span class="o">-</span><span class="mi">08</span><span class="o">-</span><span class="mi">23</span> <span class="mi">13</span><span class="p">:</span><span class="mi">14</span><span class="p">:</span><span class="mi">52</span>
<span class="n">Array</span> <span class="n">Size</span><span class="p">:</span> <span class="mi">131</span><span class="p">,</span><span class="mo">072</span>
<span class="n">Array</span> <span class="n">Size</span><span class="p">:</span> <span class="mi">100</span>
</pre></div>
<p><br></p>
<h4>Physics Remark:</h4>
<p>The <em>strain</em> recorded in the above timeseries basically represents the degree to which space has expanded
or contracted along the path of the interferometer:
</p>
<div class="math">$$h = \frac{\Delta L}{L},\quad \Delta L = L_x - L_y$$</div>
<p>
Where <span class="math">\(L\)</span> is the original length of the detector, and the change is measured as the difference in the
detector arms. For more information on the experimental setup, see the excellent review,
<a href="https://link.springer.com/article/10.1007/s41114-016-0002-8">Interferometer techniques for gravitational wave detection</a>
by Bond, Brown, Freise and Strain.</p>
<h3>Visualize the Time-Domain</h3>
<p>This section is devoted to visualizing the Time-domain strain. We use the <code>sample_times</code> attribute of
the <code>TimeSeries</code> class for the x-coordinates of the plot, and simply pass the <code>TimeSeries</code> object itself
as the y-coordinates (since it is an array). </p>
<div class="highlight"><pre><span></span><span class="c1"># Import some plotting tools from the bokeh package</span>
<span class="kn">from</span> <span class="nn">bokeh.plotting</span> <span class="kn">import</span> <span class="n">output_notebook</span><span class="p">,</span> <span class="n">show</span><span class="p">,</span> <span class="n">figure</span>
<span class="n">output_notebook</span><span class="p">(</span><span class="n">hide_banner</span><span class="o">=</span><span class="bp">True</span><span class="p">)</span> <span class="c1"># for Jupyter usage, otherwise it will write out files</span>
<span class="c1"># Create the figure</span>
<span class="n">f</span> <span class="o">=</span> <span class="n">figure</span><span class="p">(</span><span class="n">title</span><span class="o">=</span><span class="s1">'Time-Domain data around '</span> <span class="o">+</span> <span class="n">m</span><span class="o">.</span><span class="n">data</span><span class="p">[</span><span class="s1">'files'</span><span class="p">][</span><span class="s1">'eventName'</span><span class="p">],</span>
<span class="n">x_axis_type</span><span class="o">=</span><span class="s1">'datetime'</span><span class="p">,</span> <span class="n">x_axis_label</span><span class="o">=</span><span class="s1">'Time (s)'</span><span class="p">,</span> <span class="n">y_axis_label</span><span class="o">=</span><span class="s1">'Strain'</span><span class="p">,</span>
<span class="n">plot_height</span><span class="o">=</span><span class="mi">300</span><span class="p">,</span> <span class="n">plot_width</span><span class="o">=</span><span class="mi">800</span><span class="p">)</span>
<span class="c1"># Plot the line-plot data</span>
<span class="n">f</span><span class="o">.</span><span class="n">line</span><span class="p">(</span><span class="n">x</span><span class="o">=</span><span class="n">ts</span><span class="o">.</span><span class="n">sample_times</span><span class="o">.</span><span class="n">numpy</span><span class="p">(),</span> <span class="n">y</span><span class="o">=</span><span class="n">ts</span><span class="o">.</span><span class="n">numpy</span><span class="p">())</span>
<span class="c1"># Display</span>
<span class="n">show</span><span class="p">(</span><span class="n">f</span><span class="p">)</span>
</pre></div>
<p><img alt="GWaveData" src="/images/gwave-data.png" /></p>
<p><br>
<p style="background: #e6e6e6; border-radius: 10px; padding: 10px">
<i><b>Developer Note:</b></i><br>
Plotting in Python is notoriously subjective; there are many competing libraries that all deserve proper attention, such as plotly, bokeh, plotnine, altair, and others (excluding matplotlib). There are meta-plotting libraries as well that sit atop these, such as holoviews. However, we choose to use Bokeh here primarily due to the simple interface, and clean style.
</p></p>
<h2>Acknowledgments</h2>
<p>This post is based on the official <a href="https://pycbc.org/tutorials/">PyCBC tutorials</a>, and is cited in the example
repository's <a href="https://github.com/JWKennington/pycbc-examples/blob/master/README.md">README</a>. </p>
<script type="text/javascript">if (!document.getElementById('mathjaxscript_pelican_#%@#$@#')) {
var align = "center",
indent = "0em",
linebreak = "false";
if (false) {
align = (screen.width < 768) ? "left" : align;
indent = (screen.width < 768) ? "0em" : indent;
linebreak = (screen.width < 768) ? 'true' : linebreak;
}
var mathjaxscript = document.createElement('script');
mathjaxscript.id = 'mathjaxscript_pelican_#%@#$@#';
mathjaxscript.type = 'text/javascript';
mathjaxscript.src = 'https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.3/latest.js?config=TeX-AMS-MML_HTMLorMML';
mathjaxscript[(window.opera ? "innerHTML" : "text")] =
"MathJax.Hub.Config({" +
" config: ['MMLorHTML.js']," +
" TeX: { extensions: ['AMSmath.js','AMSsymbols.js','noErrors.js','noUndefined.js'], equationNumbers: { autoNumber: 'AMS' } }," +
" jax: ['input/TeX','input/MathML','output/HTML-CSS']," +
" extensions: ['tex2jax.js','mml2jax.js','MathMenu.js','MathZoom.js']," +
" displayAlign: '"+ align +"'," +
" displayIndent: '"+ indent +"'," +
" showMathMenu: true," +
" messageStyle: 'normal'," +
" tex2jax: { " +
" inlineMath: [ ['\\\\(','\\\\)'] ], " +
" displayMath: [ ['$$','$$'] ]," +
" processEscapes: true," +
" preview: 'TeX'," +
" }, " +
" 'HTML-CSS': { " +
" styles: { '.MathJax_Display, .MathJax .mo, .MathJax .mi, .MathJax .mn': {color: 'blue ! important'} }," +
" linebreaks: { automatic: "+ linebreak +", width: '90% container' }," +
" }, " +
"}); " +
"if ('default' !== 'default') {" +
"MathJax.Hub.Register.StartupHook('HTML-CSS Jax Ready',function () {" +
"var VARIANT = MathJax.OutputJax['HTML-CSS'].FONTDATA.VARIANT;" +
"VARIANT['normal'].fonts.unshift('MathJax_default');" +
"VARIANT['bold'].fonts.unshift('MathJax_default-bold');" +
"VARIANT['italic'].fonts.unshift('MathJax_default-italic');" +
"VARIANT['-tex-mathit'].fonts.unshift('MathJax_default-italic');" +
"});" +
"MathJax.Hub.Register.StartupHook('SVG Jax Ready',function () {" +
"var VARIANT = MathJax.OutputJax.SVG.FONTDATA.VARIANT;" +
"VARIANT['normal'].fonts.unshift('MathJax_default');" +
"VARIANT['bold'].fonts.unshift('MathJax_default-bold');" +
"VARIANT['italic'].fonts.unshift('MathJax_default-italic');" +
"VARIANT['-tex-mathit'].fonts.unshift('MathJax_default-italic');" +
"});" +
"}";
(document.body || document.getElementsByTagName('head')[0]).appendChild(mathjaxscript);
}
</script>Quick Python Setup2019-07-02T00:00:00-05:002019-07-02T00:00:00-05:00Jim Kenningtontag:None,2019-07-02:/blog/quick-python-setup/<h4>Motivation</h4>
<p>Python has increased in popularity to near ubiquity in the past five years. While the Python community (correctly) professes
simplicity as a major accomplishment of the language, I still get a lot of questions about how to get a python environment
setup properly. There are some lengthy guides out …</p><h4>Motivation</h4>
<p>Python has increased in popularity to near ubiquity in the past five years. While the Python community (correctly) professes
simplicity as a major accomplishment of the language, I still get a lot of questions about how to get a python environment
setup properly. There are some lengthy guides out there on this - this post will aim to summarize and explain the relevant
components to getting started.</p>
<p><strong>Note: skip to bottom if you want quick install commands</strong></p>
<h4>The Pieces</h4>
<ul>
<li><strong><em>Python</em></strong> is a language. Combination of syntax rules, semantics, keyword commands, an interpreter that can execute code abiding the rules. </li>
<li><strong><em>package</em></strong> is a self-contained, reusable piece of python code. Often a directory containing one or more python files (or more subdirectories). One typically packages python code in order to share it. There are some packages that come with the language itself (called "builtin") and others that users can install optionally (called "3rd party" packages)</li>
<li><strong><em>environment</em></strong> is a combination of a Python installation and a collection of packages. Pip can only install python packages - not any precompiled binaries (conda can do that!)</li>
<li><strong><em>conda</em></strong> is a 3rd party package manager, and frankly I find it superior to pip in almost every way. It can install packages in a variety of languages, precompiled binaries (meaning numpy will install <em>much</em> faster).</li>
<li><strong><em>miniconda</em></strong> is an environment that contains bare-bones packages only, including the conda package manager.</li>
<li><strong><em>Anaconda</em></strong> is an environment that contains a <em>large</em> amount of packages, aimed at scientific computing (such as numpy, scipy, etc)</li>
</ul>
<h4>The Process</h4>
<p>Recall that this guide is designed for novice-users, or as a reference for other users. I will assume that the user is
able to use a desktop GUI (not headless).</p>
<h5>Using Pip (not recommended)</h5>
<p>Install python using the <a href="https://www.python.org/downloads/">os-specific Python installation programs</a>. I recommend
installing the latest version of Python 3.*, since most new packages do not include support for older versions of 2.7.
The program will install all the base packages you require, including pip. At which point you can open up a command line
(terminal on Mac or CMD on Win), and use commands like <code>pip install x</code> to install a package named "x" (for more pip commands
see the <a href="https://pip.pypa.io/en/stable/quickstart/">docs</a>).</p>
<h5>Using Conda (recommended)</h5>
<p>Install <strong>miniconda</strong> using the <a href="https://docs.conda.io/en/latest/miniconda.html">install program</a>. Once installed, create
your Python environment by doing the following:</p>
<ol>
<li><code>conda create --name env1 python=3.7</code> (you can replace "env1" with the preferred name of the environment, probably something related to your current coding project. You can also replace "3.7" with whatever version of python you want to use)</li>
<li>This will do some thinking then print a list of packages that will be installed, accept this by typing <code>Y</code></li>
<li>Your environment is created! You can activate this environment (on Mac/Linux by using <code>source activate env1</code> or on Win by using <code>activate env1</code>). </li>
<li>Now that you are "in" the environment you created, you can install other packages into the environment using <code>conda install x</code> to install package "x"</li>
<li>You can also install other packages from a text file using <code>conda install --file requirements.txt</code>, where "requirements.txt" is the requirements file containing a list of package names (one on each line).
<br><br></li>
</ol>
<p>There are, of course, more complicated options available using conda, for those see
the <a href="https://docs.conda.io/projects/conda/en/4.6.0/_downloads/52a95608c49671267e40c689e0bc00ca/conda-cheatsheet.pdf">conda cheat sheet</a></p>
<h4>TL;DR - Get Python Setup</h4>
<p>The below steps give a quick, general-purpose environment setup.</p>
<ol>
<li>Install <a href="https://docs.conda.io/en/latest/miniconda.html">miniconda</a></li>
<li><code>conda create --name env1 python=3.7</code></li>
<li><code>source activate env1</code></li>
<li><code>conda install numpy scipy pandas</code>
<br><br></li>
</ol>
<p>The "env1" directory will be installed in the user x directory (<code>~/.anaconda</code> on Mac or <code>C:\Users\x\.anaconda</code> on Win).
If you are using a python editor (like PyCharm) that wants to be "pointed" to the environment, then you will configure
it to look at the "env1" directory under the ".anaconda" folder.</p>
<h4>Conda env shortcut</h4>
<p>It is also possible to create a clickable shortcut to the conda environment, see <a href="https://anaconda.org/anaconda/console_shortcut">the docs</a> for more.</p>Book Review: Tensors and Group Theory for Physcists (Jeevanjee)2019-06-28T00:00:00-05:002019-06-28T00:00:00-05:00Jim Kenningtontag:None,2019-06-28:/blog/book-review-tensors-and-group-theory-for-physcists-jeevanjee/<h5>Summary</h5>
<p>I picked up a copy of Nadir Jeevnajee's <a href="https://amzn.to/2XzHfp2">An Introduction to Tensors and Group Theory for Physicists</a>
a few months ago with the intent of skimming through and spending most of my time in reference texts. To my pleasant
surprise, I found this text to be self contained - requiring …</p><h5>Summary</h5>
<p>I picked up a copy of Nadir Jeevnajee's <a href="https://amzn.to/2XzHfp2">An Introduction to Tensors and Group Theory for Physicists</a>
a few months ago with the intent of skimming through and spending most of my time in reference texts. To my pleasant
surprise, I found this text to be self contained - requiring little to no references. The presentation is at once
mathematically rigorous and physically intuitive, alluding to well-known examples from physics throughout. I've found this
text to be such a great introduction to tensors that I have even recommended it to computer-scientist colleagues of mine
who have no interest in physics. I whole-heartedly recommend it to anyone interesting in becoming more familiar with tensors
and elementary group / representation theory.</p>
<h5>Part I: Tensors</h5>
<p>The presentation of tensors as multilinear functions achieves a remarkable degree of exposition, and arrives at all the
more heuristic definitions of tensors as derived from the simple multilinear-map definitions. This gave the impression
of a more solid ground basis for many subsequent tensorial notations and usages.</p>
<p>The derivation of commonly assumed definitions is most satisfying. Specifically, the definitions of the adjoint operator
and tensor product are much simpler than the more commonly given "behavioral" definitions presented in physics. I appreciated
the rigorous yet succinct treatment of the tensor and wedge products.</p>
<h5>Part II: Group Theory</h5>
<p>Though I am still working through the last part of chapter 6, I must admit I found this section to be superbly clear. The
methodical, sequential development of topics in Lie theory were especially thoughtful. The presentation of Lie algebra elements
as derivatives of Lie group elements yielded the conventional tangent-space definitions nicely. </p>
<p>At the same time, Jeevanjee also presents many common groups and the important relations between them, such as the double-cover
relationship of SU(2) and SO(3). He also presents the higher-level relations between the various common groups, such as the
quantum implications of the Lorentz (improper) group. Good stuff!</p>
<h5>Solutions</h5>
<p>As I read through the text I'm compiling some solutions. Much to my fortunate suprise, Dr. Jeevanjee has welcomed these
solutions as contributions to his solutions manual which he has published on
Overleaf here: <a href="https://www.overleaf.com/read/smdmygtbwtxk">Solutions Manual</a>.</p>Gravity of a Photon2019-06-15T00:00:00-05:002019-06-15T00:00:00-05:00Jim Kenningtontag:None,2019-06-15:/blog/gravity-of-a-photon/<p>A friend, who focuses primarily on experimental particle physics, recently asked me an interesting question about gravity.
Specifically, he asked how the presence of electromagnetic fields impacts the gravitational field. Applying some modern-physics
reasoning, he proposed that electromagnetic fields should exert gravitational influence because photons have momentum that
can be …</p><p>A friend, who focuses primarily on experimental particle physics, recently asked me an interesting question about gravity.
Specifically, he asked how the presence of electromagnetic fields impacts the gravitational field. Applying some modern-physics
reasoning, he proposed that electromagnetic fields should exert gravitational influence because photons have momentum that
can be viewed as mass in special relativity, and should interact gravitationally. I found this idea interesting, if a bit
interpretive, and answered with the precise formulation of the impact of the electromagnetic field on the curvature tensor.
He suggested I post this response in case anyone else finds it interesting; to colleagues working in classical or quantum gravity
this might appear a bit pedestrian.</p>
<p>The Einstein field equation (below) is arguably the most famous equation in gravity theory, second perhaps to Newton's inverse-square
law, and despite its seemingly-complex tensorial notation, expresses a beautifully elegant and simple concept. For those less
familiar, Einstein's general relativity reformulates gravitational interaction as a manifestation of the curvature of spacetime.
Specifically, Einstein's formulation makes concrete the relationship between the curvature of spacetime and the mass-energy content
of spacetime <a href='#misnerGravitation2017' id='ref-misnerGravitation2017-1'>Misner et al. (2017)</a>.</p>
<div class="math">$$R_{\mu\nu} - \frac{1}{2}Rg_{\mu\nu} + \Lambda g_{\mu\nu} = \frac{8\pi G}{c^4}T_{\mu\nu} \quad\quad\quad(1)$$</div>
<p>In the above equation (Einstein equation), the left-hand side contains terms related to curvature of spacetime, like the Ricci
tensor <span class="math">\(R_{\mu\nu}\)</span> and the metric <span class="math">\(g_{\mu\nu}\)</span>. The right-hand side contains terms related to energy and matter content,
specifically <span class="math">\(T_{\mu\nu}\)</span>. This latter term, called the <em>stress-energy</em> tensor, is where the connection to the electromagnetic
field appears.</p>
<p>Various forms of matter contribute differently to the stress-energy tensor, and electromagnetic energy is no exception. The
equation below outlines the way in which the electromagnetic field contributes to the stress energy density of a particular
area of spacetime.</p>
<div class="math">$$T^{\mu\nu} = \frac{1}{\mu_0}\left[F^{\mu\alpha}F^{\nu}{}_{\alpha} - \frac{1}{4} g^{\mu\nu}F_{\alpha\beta}F^{\alpha\beta} \right] \quad\quad\quad(2)$$</div>
<p>Where <span class="math">\(F_{\mu\nu}\)</span> is the electromagnetic field tensor, also called the <em>Faraday</em> tensor, where <span class="math">\(\mathbf{E} = E^i e_i\)</span> and
<span class="math">\(\mathbf{B} = B^i e_i\)</span> are the familiar electric and magnetic vector fields. Note that in the below, I adopt the <span class="math">\(c=1\)</span>
convention for convenience <a href='#carrollSpacetimeGeometryIntroduction2013' id='ref-carrollSpacetimeGeometryIntroduction2013-1'>Carroll (2013)</a>.</p>
<div class="math">$$F^{\mu\nu} =
\begin{bmatrix}
0 & -E^x & -E^y & -E^z \\
E^x & 0 & -B^z & B^y \\
E^y & B^z & 0 & -B^x \\
E^z & -B^y & B^x & 0 \\
\end{bmatrix} \quad\quad\quad(3)$$</div>
<p>Thus, equation (2) tells us how the electromagnetic fields we are familiar with, namely <span class="math">\(\mathbf{E}\)</span> and <span class="math">\(\mathbf{B}\)</span>,
contribute to the energy density of a region of spacetime. Then equation (1) builds on that result to relate the
electromagnetic fields to the curvature of spacetime, which as Einstein revealed, manifests as the gravitational field. So
yes, the conventional electromagnetic fields, and the photons that constitute them, impact the gravitational field despite
having no rest mass!</p>
<script type="text/javascript">if (!document.getElementById('mathjaxscript_pelican_#%@#$@#')) {
var align = "center",
indent = "0em",
linebreak = "false";
if (false) {
align = (screen.width < 768) ? "left" : align;
indent = (screen.width < 768) ? "0em" : indent;
linebreak = (screen.width < 768) ? 'true' : linebreak;
}
var mathjaxscript = document.createElement('script');
mathjaxscript.id = 'mathjaxscript_pelican_#%@#$@#';
mathjaxscript.type = 'text/javascript';
mathjaxscript.src = 'https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.3/latest.js?config=TeX-AMS-MML_HTMLorMML';
mathjaxscript[(window.opera ? "innerHTML" : "text")] =
"MathJax.Hub.Config({" +
" config: ['MMLorHTML.js']," +
" TeX: { extensions: ['AMSmath.js','AMSsymbols.js','noErrors.js','noUndefined.js'], equationNumbers: { autoNumber: 'AMS' } }," +
" jax: ['input/TeX','input/MathML','output/HTML-CSS']," +
" extensions: ['tex2jax.js','mml2jax.js','MathMenu.js','MathZoom.js']," +
" displayAlign: '"+ align +"'," +
" displayIndent: '"+ indent +"'," +
" showMathMenu: true," +
" messageStyle: 'normal'," +
" tex2jax: { " +
" inlineMath: [ ['\\\\(','\\\\)'] ], " +
" displayMath: [ ['$$','$$'] ]," +
" processEscapes: true," +
" preview: 'TeX'," +
" }, " +
" 'HTML-CSS': { " +
" styles: { '.MathJax_Display, .MathJax .mo, .MathJax .mi, .MathJax .mn': {color: 'blue ! important'} }," +
" linebreaks: { automatic: "+ linebreak +", width: '90% container' }," +
" }, " +
"}); " +
"if ('default' !== 'default') {" +
"MathJax.Hub.Register.StartupHook('HTML-CSS Jax Ready',function () {" +
"var VARIANT = MathJax.OutputJax['HTML-CSS'].FONTDATA.VARIANT;" +
"VARIANT['normal'].fonts.unshift('MathJax_default');" +
"VARIANT['bold'].fonts.unshift('MathJax_default-bold');" +
"VARIANT['italic'].fonts.unshift('MathJax_default-italic');" +
"VARIANT['-tex-mathit'].fonts.unshift('MathJax_default-italic');" +
"});" +
"MathJax.Hub.Register.StartupHook('SVG Jax Ready',function () {" +
"var VARIANT = MathJax.OutputJax.SVG.FONTDATA.VARIANT;" +
"VARIANT['normal'].fonts.unshift('MathJax_default');" +
"VARIANT['bold'].fonts.unshift('MathJax_default-bold');" +
"VARIANT['italic'].fonts.unshift('MathJax_default-italic');" +
"VARIANT['-tex-mathit'].fonts.unshift('MathJax_default-italic');" +
"});" +
"}";
(document.body || document.getElementsByTagName('head')[0]).appendChild(mathjaxscript);
}
</script><hr>
<h3>Bibliography</h3>
<p id='carrollSpacetimeGeometryIntroduction2013'>Sean Carroll.
<em>Spacetime and <span class="bibtex-protected"><span class="bibtex-protected">Geometry</span></span>: <span class="bibtex-protected"><span class="bibtex-protected">An Introduction</span></span> to <span class="bibtex-protected"><span class="bibtex-protected">General Relativity</span></span></em>.
<span class="bibtex-protected">Pearson Education</span>, 3 edition, 2013. <a class="cite-backref" href="#ref-carrollSpacetimeGeometryIntroduction2013-1" title="Jump back to reference 1">↩</a></p>
<p id='misnerGravitation2017'>Charles W. Misner, Kip S. Thorne, John Archibald Wheeler, and David Kaiser.
<em>Gravitation</em>.
<span class="bibtex-protected">Princeton University Press</span>, <span class="bibtex-protected">Princeton, N.J</span>, 2017.
ISBN 978-0-691-17779-3.
OCLC: on1006427790. <a class="cite-backref" href="#ref-misnerGravitation2017-1" title="Jump back to reference 1">↩</a></p>
Erasing Efficiently2019-05-06T00:00:00-05:002019-05-06T00:00:00-05:00Jim Kenningtontag:None,2019-05-06:/blog/erasing-efficiently/<p>I've spent time focusing on the best chalkboards and chalks on my <a href="/pages/tools">tools page</a>, but -until recently- I've
not spent much time thinking about the last part of the process -- erasing. At the suggestion of several colleagues, I
played around with several different methods of erasing chalk marks to find …</p><p>I've spent time focusing on the best chalkboards and chalks on my <a href="/pages/tools">tools page</a>, but -until recently- I've
not spent much time thinking about the last part of the process -- erasing. At the suggestion of several colleagues, I
played around with several different methods of erasing chalk marks to find which is most effective. The results were
decisive. This post outlines the results, and attempts to present a simple test as justification (though my own testing
was more extensive). </p>
<p>Of the suggestions I was given, I decided to test the methods listed below. Felt erasers were what I had always used,
and I think are the standard in many universities across the US. The sponge was an interesting suggestion, in that it has
a similar form factor to conventional felt erasers. I was most skeptical of the microfiber towel suggestion. I
thought it would feel weird to not have a handle to grab.</p>
<ol>
<li><a href="https://amzn.to/2L9k43X">Felt Eraser</a></li>
<li><a href="https://amzn.to/2PxWCMc">Sponge</a></li>
<li><a href="https://amzn.to/2GI8vLH">Microfiber Towel</a></li>
</ol>
<p>To demonstrate the differences between the methods, I drew a fair amount of horizontal lines in different colors (white,
blue, yellow, and red). I divided the lines vertically into multiple columns; one column for each method. I took a few
images after each pass.</p>
<p>A look at the tools pre-erasing, note that they are all chalk-free!
<img alt="Eraser Tools Pre" src="/images/eraser-tools-pre.png" /></p>
<p>The board after a single pass with each tool. Notice how the felt eraser just smeared the existing lines, but they are
still fully recognizable and distinguishable (bad). The sponge did a little better, but made a terrible noise while in
contact with the board. Lastly, the microfiber towel surpassed my expectations and the other competitors, erasing nearly
all trace of the lines in the first pass! Not only does the towel method erase better than the others, but it produces
less dust as well.
<img alt="After 1 Pass" src="/images/eraser-pass-1.png" /></p>
<p>The board after 5 passes with each tool. The felt eraser has closed the gap on the other methods, but still doesn't compare
fully. The microfiber towel method:
<img alt="After 5 Passes" src="/images/eraser-pass-5.png" /></p>
<p>A quick look at the tools post erasing. The felt eraser has gathered the chalk in highly-clustered places, whereas the microfiber
towel has absorbed the chalk in a fairly uniform pattern. This latter observation explains why the towel continues to work
well long after the eraser needs to be cleaned, there's a surface-area advantage!
<img alt="Eraser Tools Post" src="/images/eraser-tools-post.png" /></p>
<p>An aside about cleaning up the tools: the microfiber towels are machine-washable (do <em>not</em> use softener, only dry on low
or no heat). This is much easier than the felt erasers, which I either had to clap against eachother outdoors, or vacuum
with a special nozzle on the vacuum cleaner.</p>
<p><strong>Winner: Microfiber Towel!</strong> (I won't go back). If you prefer the form-factor of the felt eraser, wrap it in a microfiber towel!</p>Tensor Type Notation2019-04-23T00:00:00-05:002019-04-23T00:00:00-05:00Jim Kenningtontag:None,2019-04-23:/blog/tensor-type-notation/<h3>What does type (r, s) mean?</h3>
<p>I'd like to discuss the notation of the tensor type, commonly denoted <span class="math">\((r, s)\)</span> as it relates to the tensor product. Specifically,
the ordering of the vector spaces and dual vector spaces involved in the product. The order matters since tensors are typically
categorized …</p><h3>What does type (r, s) mean?</h3>
<p>I'd like to discuss the notation of the tensor type, commonly denoted <span class="math">\((r, s)\)</span> as it relates to the tensor product. Specifically,
the ordering of the vector spaces and dual vector spaces involved in the product. The order matters since tensors are typically
categorized by the number of vectors and dual vectors they require as arguments. To avoid ambiguity, for a given tensor <span class="math">\(T\)</span>, I will
denote the number of vector arguments as <span class="math">\(n_v\)</span> and the number of dual vector arguments as <span class="math">\(n_d\)</span>. </p>
<h4>Preliminaries</h4>
<p>Before we begin, recall that the dual vector space <span class="math">\(V^*\)</span> is defined as the set of linear functionals from <span class="math">\(V\rightarrow C\)</span>,
where <span class="math">\(C\)</span> is the field over which <span class="math">\(V\)</span> is a vector space. Note, the dual space <span class="math">\(V^*\)</span> is defined in terms of the vector space <span class="math">\(V\)</span>.
For similar reasons, the topic of dual spaces is introduced after the topic of vector spaces - in other words, <strong>epistemologically,
the dual space follows the vector space</strong>. I only draw attention to this ordering between the vector space and the dual because
it informs the aesthetic nature of the notation, as we'll see.</p>
<h4>Conventions</h4>
<p>The tensor type <span class="math">\((r, s)\)</span> is used to categories tensors based on the number of vectors and dual vectors they consume. Problem is,
there is a choice to made between the <span class="math">\(r=n_v\)</span> or <span class="math">\(r=n_d\)</span> conventions - and this choice isn't made consistently. As I mentioned above,
the epistemological ordering of vectors and dual vectors is unambiguous; dual vectors follow vectors. It therefore seems natural to
make the first number <span class="math">\(r\)</span> equal the number of vector arguments <span class="math">\(n_v\)</span>. I'll call this convention the <em>vector first</em> convention, or
"VF" for short. Similarly, I'll call the opposite convention, of using the number of dual vectors <span class="math">\(n_d\)</span> as the first number <span class="math">\(r\)</span>,
the <em>dual first</em> convention, or "DF" for short.</p>
<h4>Usage of Conventions</h4>
<p>Some sources that use the <em>VF</em> convention <a href='#jeevanjeeIntroductionTensorsGroup2015' id='ref-jeevanjeeIntroductionTensorsGroup2015-1'>Jeevanjee (2015)</a>, <a href='#langLinearAlgebra1987' id='ref-langLinearAlgebra1987-1'>Lang (1987)</a>. Some sources that
use the <em>DF</em> convention <a href='#romanAdvancedLinearAlgebra2007' id='ref-romanAdvancedLinearAlgebra2007-1'>Roman (2007)</a>, <a href='#hallLieGroupsLie2015' id='ref-hallLieGroupsLie2015-1'>Hall (2015)</a>, <a href='#tuDifferentialGeometryConnections2017' id='ref-tuDifferentialGeometryConnections2017-1'>Tu (2017)</a>,
<a href='#leeIntroductionSmoothManifolds2013' id='ref-leeIntroductionSmoothManifolds2013-1'>Lee (2013)</a>, <a href='#rentelnManifoldsTensorsForms2014' id='ref-rentelnManifoldsTensorsForms2014-1'>Renteln (2014)</a>, <a href='#dasTensorsMathematicsRelativity2007' id='ref-dasTensorsMathematicsRelativity2007-1'>Das (2007)</a>,
<a href='#carrollSpacetimeGeometryIntroduction2013' id='ref-carrollSpacetimeGeometryIntroduction2013-1'>Carroll (2013)</a>, <a href='#poissonRelativistToolkitMathematics2004' id='ref-poissonRelativistToolkitMathematics2004-1'>Poisson (2004)</a>, <a href='#misnerGravitation2017' id='ref-misnerGravitation2017-1'>Misner et al. (2017)</a>,
<a href='#spivakComprehensiveIntroductionDifferential1999' id='ref-spivakComprehensiveIntroductionDifferential1999-1'>Spivak (1999)</a>.
To explicitly make clear the above conventions, the <em>VF</em> convention
would define a type <span class="math">\((r, s)\)</span> tensor <span class="math">\(T\)</span> as
</p>
<div class="math">$$T: V_1\times \cdot\cdot\cdot \times V_r \times V^*_1 \times \cdot\cdot\cdot \times V^*_s\rightarrow C$$</div>
<p>
where <span class="math">\(V_{i}=V\)</span> and <span class="math">\(V^*_{i}=V^*\)</span> for all <span class="math">\(i\)</span>. On the other hand, the <em>DF</em> convention would define a type <span class="math">\((r, s)\)</span> tensor <span class="math">\(T\)</span> as
</p>
<div class="math">$$T: V^*_1\times \cdot\cdot\cdot \times V^*_r \times V_1 \times \cdot\cdot\cdot \times V_s\rightarrow C$$</div>
<p> where again
<span class="math">\(V_{I}=V\)</span> and <span class="math">\(V^*_{i}=V^*\)</span> for all <span class="math">\(i\)</span>.</p>
<h3>Cartesian vs. Tensor Product Notations</h3>
<p>The usage of Cartesian products to define the domain of <span class="math">\(T\)</span> is typically used before introducing the tensor product,
as it is more familiar. In the Cartesian product notation, the <em>VF</em> convention places the vector spaces before the dual
spaces, and in some sense is "aligned" with the way in which the subject is taught. When using the tensor product notation,
however, this is no longer the case!</p>
<p>Recall the tensor product of two vector spaces <span class="math">\(V\)</span> and <span class="math">\(W\)</span> is denoted <span class="math">\(V\otimes W\)</span> and is the set of all multilinear functions
from <span class="math">\(V^* \times W^* \rightarrow C\)</span>. Notice how the usage of the tensor product <span class="math">\(\otimes\)</span> essentially replaces vector spaces
with their duals in the Cartesian notation. This "replacement" effect combined with only using the spaces <span class="math">\(V\)</span> and <span class="math">\(V^*\)</span> amounts
to reversing the order of the input spaces the domain. For example, the <em>VF</em> convention would define a type <span class="math">\((r, s)\)</span> tensor <span class="math">\(T\)</span>
using the tensor product notation as </p>
<div class="math">$$T: V^*_1\otimes \cdot\cdot\cdot \otimes V^*_r \otimes V_1 \otimes \cdot\cdot\cdot \otimes
V_s\rightarrow C$$</div>
<p> For good measure, I will also note that the <em>DF</em> convention would define a type <span class="math">\((r, s)\)</span> tensor <span class="math">\(T\)</span> using the
tensor product notation as </p>
<div class="math">$$T: V_1\otimes \cdot\cdot\cdot \otimes V_r \otimes V^*_1 \otimes \cdot\cdot\cdot \otimes
V^*_s\rightarrow C$$</div>
<p> Notice that these definitions are equivalent to the previous definitions using Cartesian product
notation, but that now the vector spaces are written first in what we called the <em>dual first</em> convention, not the <em>vector first</em>
convention!</p>
<h3>Why is <em>DF</em> convention preferred?</h3>
<p>It seems that the <span class="math">\(DF\)</span> convention has wider usage and appeal; naturally I wonder why. Since it feels natural to align the
notation with the epistemological order, in other words, to write <span class="math">\(V\)</span> before <span class="math">\(V^*\)</span>, then I am forced to conclude that the
mathematical community, with malice of forethought, prefers to base the definition of a type <span class="math">\((r, s)\)</span> tensor on the tensor
product notation, rather than the Cartesian notation, since the former requires that <span class="math">\(V\)</span> be written before <span class="math">\(V^*\)</span>. I personally
have no objection to the choice, as it seems sensible.</p>
<h4>Parting note on terminology</h4>
<p>In the <em>DF</em> convention, the number <span class="math">\(r\)</span> is often referred to as the <em>covariant</em> number and the number <span class="math">\(s\)</span> is called the
<em>contravariant</em> number. These terms refer to the number of dual vectors and vectors respectively, since vectors are typically
considered contravariant. Similar terms refer to <em>lower</em> and <em>upper</em> indices respectively.</p>
<p>I should note that my exploration of these conventions is limited to differential geometry, relativity, and linear algebra texts. </p>
<script type="text/javascript">if (!document.getElementById('mathjaxscript_pelican_#%@#$@#')) {
var align = "center",
indent = "0em",
linebreak = "false";
if (false) {
align = (screen.width < 768) ? "left" : align;
indent = (screen.width < 768) ? "0em" : indent;
linebreak = (screen.width < 768) ? 'true' : linebreak;
}
var mathjaxscript = document.createElement('script');
mathjaxscript.id = 'mathjaxscript_pelican_#%@#$@#';
mathjaxscript.type = 'text/javascript';
mathjaxscript.src = 'https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.3/latest.js?config=TeX-AMS-MML_HTMLorMML';
mathjaxscript[(window.opera ? "innerHTML" : "text")] =
"MathJax.Hub.Config({" +
" config: ['MMLorHTML.js']," +
" TeX: { extensions: ['AMSmath.js','AMSsymbols.js','noErrors.js','noUndefined.js'], equationNumbers: { autoNumber: 'AMS' } }," +
" jax: ['input/TeX','input/MathML','output/HTML-CSS']," +
" extensions: ['tex2jax.js','mml2jax.js','MathMenu.js','MathZoom.js']," +
" displayAlign: '"+ align +"'," +
" displayIndent: '"+ indent +"'," +
" showMathMenu: true," +
" messageStyle: 'normal'," +
" tex2jax: { " +
" inlineMath: [ ['\\\\(','\\\\)'] ], " +
" displayMath: [ ['$$','$$'] ]," +
" processEscapes: true," +
" preview: 'TeX'," +
" }, " +
" 'HTML-CSS': { " +
" styles: { '.MathJax_Display, .MathJax .mo, .MathJax .mi, .MathJax .mn': {color: 'blue ! important'} }," +
" linebreaks: { automatic: "+ linebreak +", width: '90% container' }," +
" }, " +
"}); " +
"if ('default' !== 'default') {" +
"MathJax.Hub.Register.StartupHook('HTML-CSS Jax Ready',function () {" +
"var VARIANT = MathJax.OutputJax['HTML-CSS'].FONTDATA.VARIANT;" +
"VARIANT['normal'].fonts.unshift('MathJax_default');" +
"VARIANT['bold'].fonts.unshift('MathJax_default-bold');" +
"VARIANT['italic'].fonts.unshift('MathJax_default-italic');" +
"VARIANT['-tex-mathit'].fonts.unshift('MathJax_default-italic');" +
"});" +
"MathJax.Hub.Register.StartupHook('SVG Jax Ready',function () {" +
"var VARIANT = MathJax.OutputJax.SVG.FONTDATA.VARIANT;" +
"VARIANT['normal'].fonts.unshift('MathJax_default');" +
"VARIANT['bold'].fonts.unshift('MathJax_default-bold');" +
"VARIANT['italic'].fonts.unshift('MathJax_default-italic');" +
"VARIANT['-tex-mathit'].fonts.unshift('MathJax_default-italic');" +
"});" +
"}";
(document.body || document.getElementsByTagName('head')[0]).appendChild(mathjaxscript);
}
</script><hr>
<h3>Bibliography</h3>
<p id='carrollSpacetimeGeometryIntroduction2013'>Sean Carroll.
<em>Spacetime and <span class="bibtex-protected"><span class="bibtex-protected">Geometry</span></span>: <span class="bibtex-protected"><span class="bibtex-protected">An Introduction</span></span> to <span class="bibtex-protected"><span class="bibtex-protected">General Relativity</span></span></em>.
<span class="bibtex-protected">Pearson Education</span>, 3 edition, 2013. <a class="cite-backref" href="#ref-carrollSpacetimeGeometryIntroduction2013-1" title="Jump back to reference 1">↩</a></p>
<p id='dasTensorsMathematicsRelativity2007'>Anadijiban Das.
<em>Tensors: The Mathematics of Relativity Theory and Continuum Mechanics</em>.
<span class="bibtex-protected">Springer</span>, <span class="bibtex-protected">New York</span>, 2007.
ISBN 978-0-387-69468-9 978-0-387-69469-6.
OCLC: ocm77795794. <a class="cite-backref" href="#ref-dasTensorsMathematicsRelativity2007-1" title="Jump back to reference 1">↩</a></p>
<p id='hallLieGroupsLie2015'>Brian C. Hall.
<em>Lie Groups, <span class="bibtex-protected"><span class="bibtex-protected">Lie</span></span> Algebras, and Representations: An Elementary Introduction</em>.
Number 222 in Graduate Texts in Mathematics.
<span class="bibtex-protected">Springer</span>, <span class="bibtex-protected">Cham ; New York</span>, second edition edition, 2015.
ISBN 978-3-319-13466-6.
OCLC: ocn910324548. <a class="cite-backref" href="#ref-hallLieGroupsLie2015-1" title="Jump back to reference 1">↩</a></p>
<p id='jeevanjeeIntroductionTensorsGroup2015'>Nadir Jeevanjee.
<em>An Introduction to Tensors and Group Theory for Physicists</em>.
<span class="bibtex-protected">Springer Science+Business Media</span>, <span class="bibtex-protected">New York, NY</span>, 2015.
ISBN 978-3-319-14793-2. <a class="cite-backref" href="#ref-jeevanjeeIntroductionTensorsGroup2015-1" title="Jump back to reference 1">↩</a></p>
<p id='langLinearAlgebra1987'>Serge Lang.
<em>Linear Algebra</em>.
Undergraduate Texts in Mathematics.
<span class="bibtex-protected">Springer-Verlag</span>, <span class="bibtex-protected">New York</span>, 3rd ed edition, 1987.
ISBN 978-0-387-96412-6. <a class="cite-backref" href="#ref-langLinearAlgebra1987-1" title="Jump back to reference 1">↩</a></p>
<p id='leeIntroductionSmoothManifolds2013'>John M. Lee.
<em>Introduction to Smooth Manifolds</em>.
Number 218 in Graduate Texts in Mathematics.
<span class="bibtex-protected">Springer</span>, <span class="bibtex-protected">New York ; London</span>, 2nd ed edition, 2013.
ISBN 978-1-4419-9981-8 978-1-4419-9982-5.
OCLC: ocn800646950. <a class="cite-backref" href="#ref-leeIntroductionSmoothManifolds2013-1" title="Jump back to reference 1">↩</a></p>
<p id='misnerGravitation2017'>Charles W. Misner, Kip S. Thorne, John Archibald Wheeler, and David Kaiser.
<em>Gravitation</em>.
<span class="bibtex-protected">Princeton University Press</span>, <span class="bibtex-protected">Princeton, N.J</span>, 2017.
ISBN 978-0-691-17779-3.
OCLC: on1006427790. <a class="cite-backref" href="#ref-misnerGravitation2017-1" title="Jump back to reference 1">↩</a></p>
<p id='poissonRelativistToolkitMathematics2004'>Eric Poisson.
<em>A Relativist's Toolkit: The Mathematics of Black-Hole Mechanics</em>.
<span class="bibtex-protected">Cambridge University Press</span>, <span class="bibtex-protected">Cambridge, UK ; New York</span>, 2004.
ISBN 978-0-521-83091-1. <a class="cite-backref" href="#ref-poissonRelativistToolkitMathematics2004-1" title="Jump back to reference 1">↩</a></p>
<p id='rentelnManifoldsTensorsForms2014'>Paul Renteln.
<em>Manifolds, Tensors, and Forms: An Introduction for Mathematicians and Physicists</em>.
<span class="bibtex-protected">Cambridge University Press</span>, <span class="bibtex-protected">Cambridge, UK ; New York</span>, 2014.
ISBN 978-1-107-04219-3. <a class="cite-backref" href="#ref-rentelnManifoldsTensorsForms2014-1" title="Jump back to reference 1">↩</a></p>
<p id='romanAdvancedLinearAlgebra2007'>Steven Roman.
<em>Advanced Linear Algebra</em>.
Number 135 in Graduate Texts in Mathematics.
<span class="bibtex-protected">Springer</span>, <span class="bibtex-protected">New York</span>, 3rd ed edition, 2007.
ISBN 978-0-387-72828-5. <a class="cite-backref" href="#ref-romanAdvancedLinearAlgebra2007-1" title="Jump back to reference 1">↩</a></p>
<p id='spivakComprehensiveIntroductionDifferential1999'>Michael Spivak.
<em>A Comprehensive Introduction to Differential Geometry</em>.
<span class="bibtex-protected">Publish or Perish, Inc</span>, <span class="bibtex-protected">Houston, Tex</span>, 3rd ed edition, 1999.
ISBN 978-0-914098-70-6 978-0-914098-71-3 978-0-914098-72-0 978-0-914098-73-7 978-0-914098-74-4.
OCLC: ocm42962004. <a class="cite-backref" href="#ref-spivakComprehensiveIntroductionDifferential1999-1" title="Jump back to reference 1">↩</a></p>
<p id='tuDifferentialGeometryConnections2017'>Loring W. Tu.
<em>Differential Geometry: Connections, Curvature, and Characteristic Classes</em>.
<span class="bibtex-protected">Springer Science+Business Media</span>, <span class="bibtex-protected">New York, NY</span>, 2017.
ISBN 978-3-319-55082-4. <a class="cite-backref" href="#ref-tuDifferentialGeometryConnections2017-1" title="Jump back to reference 1">↩</a></p>
Tensor Product for Programmers2019-04-15T00:00:00-05:002019-04-15T00:00:00-05:00Jim Kenningtontag:None,2019-04-15:/blog/tensor-product-for-programmers/<p>The introduction to tensor products and tensor algebras is often riddled with rigor, in which a mathematician would delight but a programmer would despair. I find myself in the intersection of these camps and while I appreciate notation, a simpler introduction is possible using functional programming concepts. </p>
<p>Tensors are defined …</p><p>The introduction to tensor products and tensor algebras is often riddled with rigor, in which a mathematician would delight but a programmer would despair. I find myself in the intersection of these camps and while I appreciate notation, a simpler introduction is possible using functional programming concepts. </p>
<p>Tensors are defined and introduced in two equivalent ways. The first way, called the "expansion coefficient" (or array) style of introducing tensors relies on many indices and iterates over the n dimensions of some array (n-dimensional generalization of a matrix) <a href='#wikipediaTensorMultidimensionalArrays2019' id='ref-wikipediaTensorMultidimensionalArrays2019-1'>Wikipedia (2019)</a>. I have found this approach to be overly cluttered; missing the forest for the trees. Instead, I prefer the second way of defining tensors, namely as "multilinear maps" <a href='#romanAdvancedLinearAlgebra2007' id='ref-romanAdvancedLinearAlgebra2007-1'>Roman (2007)</a> <a href='#jeevanjeeIntroductionTensorsGroup2015' id='ref-jeevanjeeIntroductionTensorsGroup2015-1'>Jeevanjee (2015)</a>. This technique focuses on functions and interfaces, as opposed to components, and will be the chosen method of explaining below. </p>
<p>Before we begin, a brief note about preferences between the "coefficient" and "multilinear" approaches. The latter way has found greater resonance with mathematicians, while programmers often find the former more comforting. I believe this is caused by an over-reliance on data structures as atomic units of understanding. True, it is natural as a developer to ask "but what <em>is</em> the object"; however, using more functional-programming style of thought, the multilinear map approach is actually simpler! No need to keep track of various coefficients on various axes of some imaginary n-dimensional array (leave that to <code>numpy</code>). In the below, I outline a functional-programming style analogy for tensors, and the tensor product. Thought the below snippets are in python, some details are left to the imagination (i.e. this code is not a script).</p>
<h3>Setting the Stage</h3>
<p>Before we get to define tensors, we need to briefly define a few building blocks. First, there is a field <span class="math">\(C\)</span>, commonly the reals <span class="math">\(\mathbb{R}\)</span>, occasionally the complex numbers <span class="math">\(\mathbb{C}\)</span>. Members of <span class="math">\(C\)</span> are called <em>scalars</em> and are represented in the code by the type <code>scalar</code>. Second, there are vector spaces <span class="math">\(V\)</span> over this field, with the usual properties of closure under addition and scalar multiplication. Elements of <span class="math">\(V\)</span> are of type <code>vector</code>. Note, I am not specifying a vector as a tuple of scalars - though that is a valid vector space, there are others based on non-tuple like entities, like the vector space of square-integrable functions! The last piece of machinery is the dual space <span class="math">\(V^*\)</span>. If you're not familiar with the dual space, it is essentially the set of all linear functions that take 1 vector and spit out a scalar (specifically <span class="math">\(V^* = \{f: V\rightarrow C\}\)</span> where <span class="math">\(f\)</span> is linear). Elements of <span class="math">\(V^*\)</span> are of type <code>dual</code>.</p>
<h4>Some dual vectors</h4>
<p>Recall that dual vectors are functions that take a vector and return a scalar. Let <span class="math">\(f, g \in V^*\)</span>. In code:</p>
<div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">f</span><span class="p">(</span><span class="n">v</span><span class="p">:</span> <span class="n">vector</span><span class="p">)</span> <span class="o">-></span> <span class="n">scalar</span><span class="p">:</span>
<span class="k">pass</span>
<span class="k">def</span> <span class="nf">g</span><span class="p">(</span><span class="n">w</span><span class="p">:</span> <span class="n">vector</span><span class="p">)</span> <span class="o">-></span> <span class="n">scalar</span><span class="p">:</span>
<span class="k">pass</span>
</pre></div>
<h4>Tensor Product</h4>
<p>Now let's define the tensor product of <span class="math">\(f\)</span> and <span class="math">\(g\)</span> as <span class="math">\(h = f \otimes g\)</span>. What this amounts to, is combining the functional interface into a new, single tensor (function), that curries to the functions it was made from! Specifically:</p>
<div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">h</span><span class="p">(</span><span class="n">a</span><span class="p">:</span> <span class="n">vector</span><span class="p">,</span> <span class="n">b</span><span class="p">:</span> <span class="n">vector</span><span class="p">)</span> <span class="o">-></span> <span class="n">scalar</span><span class="p">:</span>
<span class="k">return</span> <span class="n">f</span><span class="p">(</span><span class="n">a</span><span class="p">)</span> <span class="o">*</span> <span class="n">g</span><span class="p">(</span><span class="n">b</span><span class="p">)</span>
</pre></div>
<p>In some sense, the tensor (or outer) product is like a concatenation operation, that joins functions together, using the superset of arguments, and passing those arguments back to the original functions returning a scalar! This definition is easy!</p>
<script type="text/javascript">if (!document.getElementById('mathjaxscript_pelican_#%@#$@#')) {
var align = "center",
indent = "0em",
linebreak = "false";
if (false) {
align = (screen.width < 768) ? "left" : align;
indent = (screen.width < 768) ? "0em" : indent;
linebreak = (screen.width < 768) ? 'true' : linebreak;
}
var mathjaxscript = document.createElement('script');
mathjaxscript.id = 'mathjaxscript_pelican_#%@#$@#';
mathjaxscript.type = 'text/javascript';
mathjaxscript.src = 'https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.3/latest.js?config=TeX-AMS-MML_HTMLorMML';
mathjaxscript[(window.opera ? "innerHTML" : "text")] =
"MathJax.Hub.Config({" +
" config: ['MMLorHTML.js']," +
" TeX: { extensions: ['AMSmath.js','AMSsymbols.js','noErrors.js','noUndefined.js'], equationNumbers: { autoNumber: 'AMS' } }," +
" jax: ['input/TeX','input/MathML','output/HTML-CSS']," +
" extensions: ['tex2jax.js','mml2jax.js','MathMenu.js','MathZoom.js']," +
" displayAlign: '"+ align +"'," +
" displayIndent: '"+ indent +"'," +
" showMathMenu: true," +
" messageStyle: 'normal'," +
" tex2jax: { " +
" inlineMath: [ ['\\\\(','\\\\)'] ], " +
" displayMath: [ ['$$','$$'] ]," +
" processEscapes: true," +
" preview: 'TeX'," +
" }, " +
" 'HTML-CSS': { " +
" styles: { '.MathJax_Display, .MathJax .mo, .MathJax .mi, .MathJax .mn': {color: 'blue ! important'} }," +
" linebreaks: { automatic: "+ linebreak +", width: '90% container' }," +
" }, " +
"}); " +
"if ('default' !== 'default') {" +
"MathJax.Hub.Register.StartupHook('HTML-CSS Jax Ready',function () {" +
"var VARIANT = MathJax.OutputJax['HTML-CSS'].FONTDATA.VARIANT;" +
"VARIANT['normal'].fonts.unshift('MathJax_default');" +
"VARIANT['bold'].fonts.unshift('MathJax_default-bold');" +
"VARIANT['italic'].fonts.unshift('MathJax_default-italic');" +
"VARIANT['-tex-mathit'].fonts.unshift('MathJax_default-italic');" +
"});" +
"MathJax.Hub.Register.StartupHook('SVG Jax Ready',function () {" +
"var VARIANT = MathJax.OutputJax.SVG.FONTDATA.VARIANT;" +
"VARIANT['normal'].fonts.unshift('MathJax_default');" +
"VARIANT['bold'].fonts.unshift('MathJax_default-bold');" +
"VARIANT['italic'].fonts.unshift('MathJax_default-italic');" +
"VARIANT['-tex-mathit'].fonts.unshift('MathJax_default-italic');" +
"});" +
"}";
(document.body || document.getElementsByTagName('head')[0]).appendChild(mathjaxscript);
}
</script><hr>
<h3>Bibliography</h3>
<p id='jeevanjeeIntroductionTensorsGroup2015'>Nadir Jeevanjee.
<em>An Introduction to Tensors and Group Theory for Physicists</em>.
<span class="bibtex-protected">Springer Science+Business Media</span>, <span class="bibtex-protected">New York, NY</span>, 2015.
ISBN 978-3-319-14793-2. <a class="cite-backref" href="#ref-jeevanjeeIntroductionTensorsGroup2015-1" title="Jump back to reference 1">↩</a></p>
<p id='romanAdvancedLinearAlgebra2007'>Steven Roman.
<em>Advanced Linear Algebra</em>.
Number 135 in Graduate Texts in Mathematics.
<span class="bibtex-protected">Springer</span>, <span class="bibtex-protected">New York</span>, 3rd ed edition, 2007.
ISBN 978-0-387-72828-5. <a class="cite-backref" href="#ref-romanAdvancedLinearAlgebra2007-1" title="Jump back to reference 1">↩</a></p>
<p id='wikipediaTensorMultidimensionalArrays2019'>Wikipedia.
Tensor, as multidimensional arrays.
<em>Wikipedia</em>, April 2019. <a class="cite-backref" href="#ref-wikipediaTensorMultidimensionalArrays2019-1" title="Jump back to reference 1">↩</a></p>
TSAPS Spring Meeting2019-03-12T00:00:00-05:002019-03-12T00:00:00-05:00Jim Kenningtontag:None,2019-03-12:/blog/tsaps-spring-meeting/<p>Three hours south east of Dallas, Physicists gathered at Stephen F. Austin university in Nacogdoches to discuss recent developments in the field. They weren't alone, though. The meeting was shared between the APS, AAPT, and SPS - so if you were interested in physics research, studying physics, or teaching physics, there …</p><p>Three hours south east of Dallas, Physicists gathered at Stephen F. Austin university in Nacogdoches to discuss recent developments in the field. They weren't alone, though. The meeting was shared between the APS, AAPT, and SPS - so if you were interested in physics research, studying physics, or teaching physics, there was something there that could hold your attention. For me, there were a couple talks related to astrophysics that seemed worth the drive; I hit the road early Friday morning to arrive in time for the first talk. </p>
<p>Dr. Billy Quarles' talk, <em>Potential for Exoplanetary Neighbors in Alpha Centauri</em>, included a brief discussion of methodologies used to detect exoplanets. Though Quarles and his collaborators recent work seemed to focus mostly in RV techniques, the discussion on photometric methods was particularly interesting. The way that he presented the problem seemed to lend itself naturally to some geometric tricks that would allow for closed-form solutions to the intensity of the star during an exoplanet transit. I am drafting an analysis of these tricks presently, and will update this post with a link once complete - however the sketch goes something like this:</p>
<p>Let an exoplanet of mass <span class="math">\(m\)</span> orbit a star of mass <span class="math">\(M\)</span> (clearly, <span class="math">\(m < M\)</span>). The ellipticity of this orbit isn't immediately important, since we're going to make a few simplifying assumptions. First we use <span class="math">\(T \cup \mathcal{O}(3)\)</span> invariance of the trajectory geometry to align the orbital plane with the <span class="math">\(x\)</span> - <span class="math">\(y\)</span> plane in <span class="math">\(\mathcal{R}^3\)</span>. We also choose to align the orbital angular momentum <span class="math">\(L\)</span> with the <span class="math">\(z\)</span> axis of <span class="math">\(\mathcal{R}^3\)</span>. Next, we choose a reference point <span class="math">\(p\)</span> along the <span class="math">\(x\)</span> axis to serve as the "observer". When the observer is sufficiently far from the planetary system, as the Earth is from even our nearest neighboring system, then we may approximate the path of the light exiting the system as a projection along the <span class="math">\(x\)</span> axis into the <span class="math">\(y\)</span> - <span class="math">\(z\)</span> plane, namely <span class="math">\(\pi_{1}: \mathcal{R}^3 \rightarrow \mathcal{R}^2\)</span> defined by <span class="math">\(\pi_{1}(x, y, z) = (y, z)\)</span>. This assumption allows us to reduce the problem of intersecting volumes to one of intersecting areas! The remaining geometric problem can thus be stated: Given two circles <span class="math">\(S_{p1}^1(r_1)\)</span> and <span class="math">\(S_{p_2}^1(r_2)\)</span>, where the centers <span class="math">\(p_1\)</span> and <span class="math">\(p_2\)</span> are represented as smooth functions of time <span class="math">\(\alpha_1(t)\)</span> and <span class="math">\(\alpha_2(t)\)</span>, give the intersectional area <span class="math">\(A_{\cap}(t)\)</span> as a function of time. The intensity of the star during transit will be proportional to this function to a first order.</p>
<script type="text/javascript">if (!document.getElementById('mathjaxscript_pelican_#%@#$@#')) {
var align = "center",
indent = "0em",
linebreak = "false";
if (false) {
align = (screen.width < 768) ? "left" : align;
indent = (screen.width < 768) ? "0em" : indent;
linebreak = (screen.width < 768) ? 'true' : linebreak;
}
var mathjaxscript = document.createElement('script');
mathjaxscript.id = 'mathjaxscript_pelican_#%@#$@#';
mathjaxscript.type = 'text/javascript';
mathjaxscript.src = 'https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.3/latest.js?config=TeX-AMS-MML_HTMLorMML';
mathjaxscript[(window.opera ? "innerHTML" : "text")] =
"MathJax.Hub.Config({" +
" config: ['MMLorHTML.js']," +
" TeX: { extensions: ['AMSmath.js','AMSsymbols.js','noErrors.js','noUndefined.js'], equationNumbers: { autoNumber: 'AMS' } }," +
" jax: ['input/TeX','input/MathML','output/HTML-CSS']," +
" extensions: ['tex2jax.js','mml2jax.js','MathMenu.js','MathZoom.js']," +
" displayAlign: '"+ align +"'," +
" displayIndent: '"+ indent +"'," +
" showMathMenu: true," +
" messageStyle: 'normal'," +
" tex2jax: { " +
" inlineMath: [ ['\\\\(','\\\\)'] ], " +
" displayMath: [ ['$$','$$'] ]," +
" processEscapes: true," +
" preview: 'TeX'," +
" }, " +
" 'HTML-CSS': { " +
" styles: { '.MathJax_Display, .MathJax .mo, .MathJax .mi, .MathJax .mn': {color: 'blue ! important'} }," +
" linebreaks: { automatic: "+ linebreak +", width: '90% container' }," +
" }, " +
"}); " +
"if ('default' !== 'default') {" +
"MathJax.Hub.Register.StartupHook('HTML-CSS Jax Ready',function () {" +
"var VARIANT = MathJax.OutputJax['HTML-CSS'].FONTDATA.VARIANT;" +
"VARIANT['normal'].fonts.unshift('MathJax_default');" +
"VARIANT['bold'].fonts.unshift('MathJax_default-bold');" +
"VARIANT['italic'].fonts.unshift('MathJax_default-italic');" +
"VARIANT['-tex-mathit'].fonts.unshift('MathJax_default-italic');" +
"});" +
"MathJax.Hub.Register.StartupHook('SVG Jax Ready',function () {" +
"var VARIANT = MathJax.OutputJax.SVG.FONTDATA.VARIANT;" +
"VARIANT['normal'].fonts.unshift('MathJax_default');" +
"VARIANT['bold'].fonts.unshift('MathJax_default-bold');" +
"VARIANT['italic'].fonts.unshift('MathJax_default-italic');" +
"VARIANT['-tex-mathit'].fonts.unshift('MathJax_default-italic');" +
"});" +
"}";
(document.body || document.getElementsByTagName('head')[0]).appendChild(mathjaxscript);
}
</script>Mass of Sound waves2019-03-05T00:00:00-06:002019-03-05T00:00:00-06:00Jim Kenningtontag:None,2019-03-05:/blog/mass-of-sound-waves/<p>A recent article published in Physical Review B by <a href="https://journals.aps.org/prb/abstract/10.1103/PhysRevB.97.134516">Nicolis and Penco</a>
arrives at an unconventional physical assertion: that non-relativistic sound waves carry gravitational mass.</p>
<p>This claim should sound odd to anyone who has taken an undergraduate mechanics course, as one of the first physical assertions
about waves is that …</p><p>A recent article published in Physical Review B by <a href="https://journals.aps.org/prb/abstract/10.1103/PhysRevB.97.134516">Nicolis and Penco</a>
arrives at an unconventional physical assertion: that non-relativistic sound waves carry gravitational mass.</p>
<p>This claim should sound odd to anyone who has taken an undergraduate mechanics course, as one of the first physical assertions
about waves is that they transport energy <em>through</em> matter (which possesses gravitational mass), but not having any
mass of it's own. The original paper focuses on the focused effect of such behavior on condensed matter solids, though
they authors assert the result is more general.</p>
<p>If we assume their result to be true, then I find the following train of thought interesting. Given a sound wave propagating through
a solid that itself possesses gravitational mass, to what extent do the sound wave and the medium interact gravitationally? Are
there any circumstances (very "loose" media, such as IGM) under which that interaction would play an important role in the dynamics
of the resulting wave? </p>
<p>Though the above questions are tempting - I'll wait until Nicolis and Penco either experimentally observe their proposed effect,
or can present a more general version of their initial results. Either way - interesting!</p>