YeSS

Solkars Senf zu Mathe, Physik, dem Universum und dem ganzen Rest...

Moderator: Solkar

YeSS

Beitragvon Solkar » Donnerstag 19. Juli 2012, 17:30

THIS IS WORK IN PROGRESS.

YeSS - Yet (often) elaborated SR Stuff

More often than not I encounter a certain kind of people I'm tempted to call 'Pop art SR critics'.
It's about a certain flavor of 'alternative approaches' (to put it put overly tame) to solving the problems already solved by Special Relativity (SR):

- highly creative in finding colorful metaphors and sort-of 'knockout' thought experiments
- often highly creative in giving colorful names to Einstein's findings and himself
- highly creative in redefining physical quantities and terms
- and last not least highly creative in inventing a most intuitive own formalism:

Sample SR critics Pop artist: "I'm not obliged to use 'E' for Energy!".
My cynical weaker self: No, of course not. It's of course much more intuitive to label it 'F'...


Besides all the colorfulness and creativity Pop art SR critics usually demonstrate, there's another common trait - the failure to show that those highly creative approaches do better, or at least as good as, SR does in terms of consistency with empirical data.

The most often occurring, also also most obvious, lapse of that kind is 'forgetting' to test the Pop art theorem by applying it on Electrodynamics (ED) and demonstrating that they leave the wave equation (WE) of ED invariant.

Recently I felt again the need to have some assembly of the Lorentz Transformation LT (and, as a counter-example, the Galilean Transformation (GT) ) applied on the WE along with the basic maths needed to elaborate on the maths in a c&p-friendly form.

So I will deposit here some maths useful to elaborate on that and, of course, the application of transformations on the WE in both LaTeX and Unicode; the former mixed with some prose explanations, the latter maths only.

Of course, anyone who spots an error is highly welcome to point me to it, but pls dont let this turn into a general debate about SR and SR critics - this is just intended for having some stock of c&p-friendly formulae handy for debates to come and for nothing else.


Table of Contents(to be expanded incrementally)
- Notation and Conventions
- Transformation of operators
- Some useful derivatives
- Relativistic velocity-addition (1 spatial dim only) (externally at MAHAG forum, German, Unicode)
- Galilean and Lorentz transformations
- C++ tool for numerics
- ...

THIS IS WORK IN PROGRESS.
"Was macht die Bratze da auf dem Sofa?"
Aus einem "Jungen Deutschen Film" - Ausspruch einer aufgeräumt wirkenden Nackten, die am Spätvormittag in ein WG-Zimmer voller bekleideter, aber derangiert wirkender Männer tritt.
Benutzeravatar
Solkar
 
Beiträge: 371
Registriert: Freitag 11. November 2011, 20:40

Notation and Conventions

Beitragvon Solkar » Freitag 20. Juli 2012, 14:24

THIS IS WORK IN PROGRESS.


  • Units are SI units; we carry \(c\) along
  • Indices of vectors including a time component start at 0, with time coordinate being at 0th position. That implies that the first (e.g.Cartesian "x") coordinate carries the index "1", which makes the passage from conventional 3-component spatial vectors to 4-Vector calculus smooth. Consequently, spatial 3-component vectors start at index "1" (and are Cartesian unless stated otherwise).
  • Signature Convention is "-2", meaning $$\eta_{\mu\nu} = diag(+1,-1,-1,-1)$$
  • Einstein Notation is used; e.g. $$\frac{\partial \overline{x}^{\nu}}{\partial x^{\mu}} \frac{\partial}{\partial \overline{x}^{\nu}} :\equiv \sum\limits_{\nu = 0}^{N-1}\frac{\partial \overline{x}^{\nu}}{\partial x^{\mu}}\frac{\partial}{\partial \overline{x}^{\nu}},$$ "\(N\)" denoting the number of respective dimensions.
  • Lorentz \(\gamma\) and \(\beta\) $$\beta := \frac{v}{c}$$ and $$\gamma := \frac{1}{\sqrt{1-\beta^2}}.$$


Table of Contents
THIS IS WORK IN PROGRESS.
Benutzeravatar
Solkar
 
Beiträge: 371
Registriert: Freitag 11. November 2011, 20:40

Transformation of operators

Beitragvon Solkar » Sonntag 22. Juli 2012, 15:47

THIS IS WORK IN PROGRESS.
Let's recap sth. from linear algebra first:

Given an n-dimensional vectorspace \(V\) over a field \(\mathcal{F}\), a vector \(\vec{v} \in V\) and a representation of that vector by a tuple of scalars \(\left(x^{i}\right)\) with respect to a certain basis \(\left(\vec{e}_i \right)\), the vector can be written as a linear combination
$$ \vec{v} = \sum\limits_{i}x^{i} \vec{e}_i.$$Given a passive transformation \(\Lambda^{i}_{j}\)
$$\Lambda^{i}_{j}: \left(\vec{e}_i \right) \rightarrow (\vec{\overline{e}}_j)$$ that maps the old basis \(\left(\vec{e}_i \right)\) onto a new basis \((\vec{\overline{e}}_j)\) we want the equality
$$ \sum\limits_{i} x^{i} \vec{e}_i = \vec{v} = \sum\limits_{j} \overline{x}^{j} \vec{\overline{e}}_j\qquad (I)$$ to hold.

---

Let's consider now a function \(\hat{f}\) that maps \(V\) "somewhere", and chose this "somewhere" to be \(\mathcal{F}\) itself for simplicity sake; let us further choose \(V \equiv ℝ^n\) and \(\mathcal{F} \equiv ℝ\); thus we get
$$\begin{align}\hat{f} : ℝ^n \rightarrow ℝ\\ \vec{v} \rightarrow \hat{f}(\vec{v}).\end{align}$$
Although the explicit form (which we will label \(f\) and \(\overline{f}\) according to the basis used for writing down an explicit representation of \(\hat{f}\)) of \(\hat{f}\) may change under a change of basis, we would not want the resulting value depending on the choice of basis, so we want the relation $$\overline{f}((\overline{x}^j)) = f((x^i)) \qquad (II)$$ to hold.

Now let's consider the partial derivative of \(\overline{f}\) with respect to the \(\alpha\)-th component $$\frac{\partial}{\partial \overline{x}^\alpha} \overline{f}((\overline{x}^j)).$$ From eq \((I)\) above we take it that the new coordinates \(\overline{x}^{j}\) can expressed be as functions of the old coordinate tuple \(({x}^{i})\): $$\overline{x}^{j} \equiv \overline{x}^{j} (\,({x}^{i})\,),$$ and vice-versa $$x^{i} \equiv x^{i} (\,(\overline{x}^{j})\,).$$

The latter gives rise to the notion of another derivate $$ \frac{\partial}{\partial \overline{x}^\alpha} f(\,(x^i)\,) = \frac{\partial}{\partial \overline{x}^\alpha} f(\,(x^i(\,(\overline{x}^{j})\,)\,), $$

which can be evaluated by applying chain rule
$$D(f \circ g) = D(f) \circ D(g) $$
on the right side

$$\begin{align}\frac{\partial}{\partial \overline{x}^\alpha} f(\,(x^i(\,(\overline{x}^{j})\,)\,) &= \left<\nabla{f}, \left(\frac{\partial x_i}{\partial \overline{x}^{\alpha}}\right)\right>\\
&= \sum\limits_{i}\frac{\partial f}{\partial x^i} \frac{\partial x^i}{\partial \overline{x}^{\alpha}}\\
&= \sum\limits_{i}\frac{\partial x^i}{\partial \overline{x}^{\alpha}} \frac{\partial}{\partial x^i} f(\,(x^i(\,(\overline{x}^{j})\,)\,). \end{align}$$

Scratching \(f(\,(x^i(\,(\overline{x}^{j})\,)\,)\) we arrive at the symbolic equation
$$\frac{\partial}{\partial \overline{x}^\alpha} \equiv \sum\limits_{i}\frac{\partial x^i}{\partial \overline{x}^{\alpha}} \frac{\partial}{\partial x^i},$$

which is often simplified using Einstein Notation
$$ \frac{\partial}{\partial \overline{x}^{\mu}} = \frac{\partial x^{\nu}}{\partial \overline{x}^{\mu}} \frac{\partial}{\partial x^{\nu}}.\quad(III) $$

Eq. (III) is also well known from tensor calculus; recall that \(\frac{\partial}{\partial \overline{x}^{\mu}}\) and \(\frac{\partial}{\partial x^{\nu}}\) are (0,1) tensors; (III) is simply the respective covariant tensor transformation rule.

Table of Contents
THIS IS WORK IN PROGRESS.
Benutzeravatar
Solkar
 
Beiträge: 371
Registriert: Freitag 11. November 2011, 20:40

Some useful derivatives

Beitragvon Solkar » Dienstag 24. Juli 2012, 17:10

THIS IS WORK IN PROGRESS

  • \(d\tau\) ("d-tau")
    $$\begin{align}ds^2 &= c^2d\tau^2 = c^2dt^2 - dx^2\\
    \Rightarrow d\tau &= \sqrt{dt^2 - \frac{1}{c^2}dx^2} = \sqrt{\left(\frac{dt}{dt}\right)^2 - \frac{1}{c^2}\left(\frac{dx}{dt}\right)^2}\,dt \\
    \Rightarrow d\tau &= \sqrt{1 - \frac{v^2}{c^2}}\,dt := \underline{\frac{1}{\gamma}\,dt }\end{align}$$
  • ...

Table of Contents
THIS IS WORK IN PROGRESS
Benutzeravatar
Solkar
 
Beiträge: 371
Registriert: Freitag 11. November 2011, 20:40

Galilean and Lorentz transformations

Beitragvon Solkar » Montag 6. August 2012, 16:49

Let \(v\) be the relative velocity of inertial systems \(\Sigma^{\mu}\) and \(\overline{\Sigma}^{\nu}\)

Galilean¹ transformation
\(\Gamma_{\mu}^{\nu} : \overline{x}^{\mu} \rightarrow x^{\nu}\)
is given by
\(\Gamma_{\mu}^{\nu} = \left(\begin{array}{c c} &1 &0\\&{-v} &{1}\end{array}\right),\)
acting from the left
\(\overline{x}^{\nu} = \Gamma_{\mu}^{\nu} x^{\mu}\)
on column (2-) vectors \(x^{\mu}\) bearing \(t\) atop.

Lorentz² transformation
\(\Lambda_{\mu}^{\nu} : x^{\mu} \rightarrow \overline{x}^{\nu}\)
is given by
\(\Lambda_{\mu}^{\nu} = \left(\begin{array}{c c} &\gamma &{-\beta\gamma}\\&{-\beta\gamma} &{\gamma}\end{array}\right),\)
acting likewise.

¹Galileo Galilei, Italian Scientist, 1564 – 1642
²Hendrik Antoon Lorentz, Dutch Physicist, 1835 – 1928, 1902 Nobel Laureate of Physics (shared with Pieter Zeeman)

Table of Contents
Benutzeravatar
Solkar
 
Beiträge: 371
Registriert: Freitag 11. November 2011, 20:40

C++ Tool for numerics

Beitragvon Solkar » Freitag 17. August 2012, 10:18

Small C++ tool for some numerical relativistic calcs.

Code: Alles auswählen
/**
* @file sr2.cpp
* @brief Numerical simulation of special relativity event transformations
* @authors Solkar (sk)
*         (to be contacted via PM system of http://forum.alltopic.de/)
*
* @version 0.9.1 Aug 17th 2012 (sk)
*      @bug no input stream validation yet
*      @todo implement input stream validation (std::stringstream and boost::tokenizer)
*      @todo improve docs
*
* history:
*      0.9 Aug 16th 2012 (sk)
* ==================================================================================================================
*
* Compilation
* -----------
* @code g++ sr2.cpp -o sr2
*
* Compilation of v0.9 worked with g++ (GCC) 4.7.0 and boost 1.49
*
* Invocation
* ----------
* @code echo <ti> <ri> <tf> <rf> <d> | ./sr2
*
* where
*      <ti>, <ri> are _i_nitial event time and location (1 spatial dim only)
*      <tf>, <rf> are _f_inal event time and location
*      <d> is increment of velocity to be used for sampling respective LT.
*
*      velocity is to be given given in decimal fractions of speed of light
*      <ri> and <rf> have to be specified as lightdistance according to the implied unit of <ti> and <ri>,
*      e.g. if [<ti>] = [<tf>] = min = 60s => [<ri>] = [<rf>] = c*min = 60*c*s
*
* Example usage:
* --------------
* @code echo 0 -4 8 4 .5 | ./sr2
*
** outputs
** v = -0.50  t'_i = -2.31  x'_i' = -4.62  t'_f = 11.55  x'_f' =  9.24  Δt = 13.86  Δx = 13.86  c = Δx/Δt =  1.00
** v =  0.00  t'_i =  0.00  x'_i' = -4.00  t'_f =  8.00  x'_f' =  4.00  Δt =  8.00  Δx =  8.00  c = Δx/Δt =  1.00
** v =  0.50  t'_i =  2.31  x'_i' = -4.62  t'_f =  6.93  x'_f' =  0.00  Δt =  4.62  Δx =  4.62  c = Δx/Δt =  1.00
*
* ==================================================================================================================
*
*
* @copyright GNU General Public License 3.0 as of Aug 16th 2012
*      http://www.gnu.org/copyleft/gpl.html
*
* @warranty None, neither expressed nor implied
*
* Thanks to:
*      User Chief of http://mahag.com/neufor for proposing a fundamental scenario
*      User Highway of http://mahag.com/neufor for prototyping this on a spreadsheet
*              starting here http://mahag.com/neufor/viewtopic.php?p=46358#p46358
*
*/
#include <functional>                           // f. std::binary_function
#include <cmath>                                // f. sqrt
#include <iostream>                             // f. cin, cout etc
#include <iomanip>                              // f. setw


#ifdef COMPILE_PROBLEM
#include <boost/version.hpp>
#endif

#include <boost/numeric/ublas/vector.hpp>       // BLAS - Basic Linear Algebra
#include <boost/numeric/ublas/matrix.hpp>       // Subprograms

namespace blas = boost::numeric::ublas;

#ifndef COMPILE_PROBLEM
///
/// @class Lorentz_2Dim
/// @brief LT Functor - populates a 2x2 Matrix for a given velocity
///
template<
   typename T
> struct Lorentz_2Dim : public std::binary_function<blas::matrix<T>, T, void> {

    /// @param[in] v velocity given as decimal fraction of c
    /// @returns   Lorentz γ = 1.0/sqrt(1.0-v²)
   inline T gamma(T v) {
       return T(1.0)/sqrt(T(1.0)-v*v);
   }

    /// ///////////////////////////////////////////////////////////////////////
    /// Populating the Matrix
    /// ///////////////////////////////////////////////////////////////////////

    /// @param[inout] L 2x2 Matrix to be populated
    /// @param[in]    v velocity given as fraction of c
    /// @returns      void
   inline void operator() (blas::matrix<T>& L, T v) {
       L(1,1) = L(0,0) = this->gamma(v);
       L(0,1) = L(1,0) = -v * L(0,0);
   }
};
#endif // #ifndef COMPILE_PROBLEM

/// Main Program
int main () {
    typedef float real_t;
    using std::setw; // to shorten the output code

#ifdef COMPILE_PROBLEM
    std::cout << "Boost version: " << BOOST_LIB_VERSION << "\n";
#else

    /// to be read from stdin
    blas::vector<real_t> xi_(2), xf_(2); /// given initial and final events
    blas::vector<real_t> yi_(2), yf_(2); /// dto. transformed
    real_t inc;                          /// increment

    /// for looping
    blas::matrix<real_t> L(2,2);        /// LT Matrix in waiting
    Lorentz_2Dim<real_t> make_ltm;      /// functor for re-populating L
    real_t v;                           /// current velocity

    /// gathering data
    std::cin >> xi_[0] >> xi_[1] >> xf_[0] >> xf_[1] >> inc;

    v = -1.0 + inc;
    while ((v > -1.0) && (v < 1.0)) {
        /// re-populating the LT Matrix
        make_ltm(L,v);

        /// ///////////////////////////////////////////////////////////////////
        /// applying the transformation
        /// ///////////////////////////////////////////////////////////////////
        yi_ = prod(L,xi_);
        yf_ = prod(L,xf_);

        /// output
        std::cout.precision(2);
        std::cout << std::fixed;
        std::cout << "v = "           << setw(5) << v
                  << "  t'_i = "      << setw(5) << yi_[0]
                  << "  x'_i' = "     << setw(5) << yi_[1]
                  << "  t'_f = "      << setw(5) << yf_[0]
                  << "  x'_f' = "     << setw(5) << yf_[1]
                  << "  Δt = "        << setw(5) << (yf_[0] - yi_[0])
                  << "  Δx = "        << setw(5) << (yf_[1] - yi_[1]);

        /// if lightlike
        if ((pow((xf_[0] - xi_[0]),2) - pow((xf_[1] - xi_[1]),2)) == 0)
                   std::cout <<  "  c =" << setw(5);

        std::cout << " Δx/Δt = " << setw(5)
                  << (yf_[1] - yi_[1])/(yf_[0] - yi_[0])
                  << std::endl;
        /// next
        v += inc;
    } // while ((v > -1.0) && (v < 1.0))

#endif // #ifdef COMPILE_PROBLEM
} // int main ()



EDIT 13:27 P.M. Update 0.9 -> 0.9.1
Table of Contents
Benutzeravatar
Solkar
 
Beiträge: 371
Registriert: Freitag 11. November 2011, 20:40


Zurück zu Vulcan Chillout Lounge

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 2 Gäste

cron