Endgültige Widerlegung der SRT

[Kurt]

Wie soll er denn feststellen wie sich sein, von ihm erzeugter, Lichtblitz ausdehnt, das kann er nicht.

Doch doch.
An diesen Hohlkugel-Teilspiegel-Sphären z.B. würden teilweise Photonen direkt zu ihm reflektiert.
Die Zeiten u.ä. würden ihm dann die Umwelt vermitteln.

Ein wehementes Nein!

Schau dir den Bezug an der hier verwendet wird.
Selbst wenn es Photonen geben würde, diese zurücksenden würden, es käme nicht dieses Bild wieder zustande.
Denn der Bezug für das reflektiere Licht steht ja still und das Kreuz in der Mitte bewegt sich dagegen.
Es kann unmöglich das rauskommen was angedacht ist.
Die braunen Punkte wären genau so verteilt wie die grünen.
Betrachte einfach das Laufverhalten der sich entfernenden "Photonen".
Sie gehorchen dem gleichem Bezug (Prinzip) wie die grünen.
Der Empfänger läuft ihnen davon bzw. entgegen.
Es kann aus Sicht des braunen kreuzes nur c +/- v geben.
Aber das ganze Bild ist in sich nicht schlüssig, denn wenn transformiert wird dann sollte es ja passen.
Und wenn man hier auf einen anderen Planeten rübertransformieren würde dann käme ein völlig anderes Ergebnis raus als dort herrscht.
Denn dort würde es -grün- zugehen.

Gruss Kurt

[galactic32]

Ein wehementes Nein!

Ein vehementes aber sicher doch!

Denn der Bezug für das reflektiere Licht steht ja still und das Kreuz in der Mitte bewegt sich dagegen.
Es kann unmöglich das rauskommen was angedacht ist.

Bedenke unser Labor ist bereits im Universalen Bezug (CMB gegen Strenbild Löwe 300 Km/sec!) !

Die braunen Punkte wären genau so verteilt wie die grünen.

Das ist so noch nicht entzerrt.
Beim debuggen müßte also noch die correctur von alpha und alpha' durchgeführt werden!

Betrachte einfach das Laufverhalten der sich entfernenden "Photonen".
Sie gehorchen dem gleichem Bezug (Prinzip) wie die grünen.

Im perfect Transformierten Fall sollten Sie das auch!

Es kann aus Sicht des braunen kreuzes nur c +/- v geben.

In erster Näherung auf keinen Fall.
Das soll ja Embacher in seinem Clip genau wegtransformiert haben!
(Ich sag mal so, im meinem Sinne wäre die t'-„Zeit“, die Zeit des braunen Kreuzes in dessem System unter Umständen völlig nicht nach Deinem Zeit-Verständniß)

Aber das ganze Bild ist in sich nicht schlüssig, denn ...

Für Faber's Grund-Vorrausetzungen schon.
Um eine ausgereifte Trans-Formation zu finden bedarf es noch etwas weniger Fehler in dem mathematischen Teil.
Wie erwähnt, so Lorentz a là y=y' ist fraglich und sehr vermutlich falsch bzw. zu corrigiren!

Übrigens aus x²+y²=(ct)² folgt ==> ct*sin(alpha)=x , … für Faber's Photonen-Beispiel-Daumen-Kino.

In der Hinsicht muß sich wohl auch die verzerrt Winkel-Darstellung gegenüber dem gegrüntem System zeigen!

Gruß

[galactic32]

Die Animation des Gestr. System zeigt ncoh ettliche Unklarheiten!

Da hat er recht glaube ich, denn offenbar geht das gestrichene System nicht in das ungestrichene über bei kleinen Geschwindigkeiten.

Im Gegenteil.
Also bei kleinen Geschwindigkeiten morpht sich das sogar eher richtig zum grünen, schätze ich mal so salopp .
Oder was würde "optisch" oder logisch dann nicht zumindest "besser" passen?

Gruß

[galactic32]

Denn diese ist in den Köpfen immer noch als: " Die Erde bewegt sich mit xxx km/sek"

Und das ist der Fehler!!!
Licht das auf der Erdoberfläche läuft -weiss- von dieser Geschwindigkeit nichts.
Es bewegt sich so wies der auf der Erdoberfläche herrschende Bezug vorgibt.
Dieser ist an die Erdoberfläche -angenagelt-.

So absolut formuliert?
Wie darf ich messen, was Licht -weiss- ?

Wir haben allen Grund zur Vermutung, daß Licht sehr gut weiß, ob sich die Erde mit xyz km/sek bewegte (im Medium)!

Ansatzweise versteht's ja H. Sommer ganz richtig ==> Gibt es den Archimedischen Punkt ?

Denn die Bezüge sind immer ortsabhängig.

Orte sind bezugsabhängig!Orte gibt’s nur im Bezugs-Ort-System, sorum oder?

Gruß

[Faber]

Auch eine rein mathematische Sichtweise passt da nicht.

Sie sind alles andere als scharfsinnig! Die SRT ist eine mathematische Konzeption. Und dieser Strang handelt davon, ob die rein mathematische Konzeption namens SRT, die von Platons Proportionen, von Euklids Geometrie und von Galileis Relativitätsprinzip handelt, wider den gesunden Menschenverstand und die festen Regeln der Logik geht, oder nicht. Und dafür gibt es Kriterien. Kriterien, die anzeigen, ob wir es mit spinnerten Idioten wie "Kurt" zu tun haben, oder mit vernünftigen Zeitgenossen, die die Grundlagen des vernünftigen Denkens beherrschen. Prof. Einstein will mathematisch beweisen, also haben wir mathematisch zu widerlegen, wenn uns etwas nicht in dern Kram passt.

Blödsinnige Pöbeleien gegen die Mathematik zeugen von Schwachsinn, und sonst von gar nichts.

Gruß
Faber

[galactic32]

Blödsinninge Pöbeleien gegen die Mathematik zeugen von Schwachsinn, und sonst von gar nichts.

Na na na.
So wahr der Cirkel-Logik dieser Aussage auch nichts entgegenzusetzen wäre.
Allerdings wie ausgereift darf man sich unser momentan menschliches Mathe-Verständniß denn so einschätzen?Hm?

Den Informations-Fluß z.B, den man erst in der Informatik bewußter anwendet , der ist in der bisherigen Lehre doch noch aüßerst unbekannt!

Gruß

[Faber]

• Ein und dasselbe Geschehen kann nicht gleichberechtigt in dem einen oder anderen Bezugssystem beschrieben werden. Die Beschreibungen liefern unterschiedliches Geschehen.

Ich dachte lediglich, dass man damit diesen Punkt aus dem Fazit noch besser verdeutlichen könnte.

Nun, woran erkennt man unzweifelhaft und klar, dass nicht ein und dasselbe Geschehen in den beiden inertialen Bezugssystemen dargestellt wird?



Frage: Warum ist nicht ein und dasselbe Geschehen dargestellt?

Antwort: Während in bezug auf das Laborsystem Blitzgerät und Mittelpunkt der Lichtsphäre immer dieselbe Position einnehmen, nehmen sie im gestrichenen System nicht immer dieselbe Position ein. Der Physiker spricht von `Ereignissen'. Ein Ereignis A ist nichts anderes als ein punktförmiges Objekt, das sich zu einem bestimmten Zeitpunkt tA bzw. tA' an einer bestimmten Position (xA;yA;zA) bzw. (xA';yA';zA') im Raum befindet. Es ereignet sich, dass sich das Objekt zur angegebenen Zeit an der angegebenen Position befindet. Ein Ereignis ist ein eindeutiger 4D-Punkt (xA;yA;zA;tA) bzw. (x'A;y'A;z'A;t'A) in der Raumzeit. Nun zeigt das Bild, das ich mit der Hilfe und Korrektur von Gluon erstellt habe, dass die Ereignisfolge* `Blitzgerät' und die Ereignisfolge* `Mittelpunkt der Lichtausbreitung' im Laborsystem identisch sind, während sich im gestrichenen System zwei unterschiedliche Ereignisfolgen ergeben.

Sei [xA(t);yA(t);zA(t)] die Ereignisfolge `Mittelpunkt der Lichtausbreitung' im Laborsystem.
Sei [x'A(t');y'A(t');zA'(t')] die Ereignisfolge `Mittelpunkt der Lichtausbreitung' im gestrichenen System.
Sei [xB(t);yB(t);zB(t)] die Ereignisfolge `Blitzgerät' im Laborsystem.
Sei [x'B(t');y'B(t');z'B(t')] die Ereignisfolge `Blitzgerät' im gestrichenen System.

Dann gilt zwar einerseits [xA(t);yA(t);zA(t)] = [xB(t);yB(t);zB(t)] für alle Zeitpunkte t, andererseits gilt aber nicht [x'A(t');y'A(t');z'A(t')] = [x'B(t');y'B(t');z'B(t')] für alle Zeitpunkte t'. Wir haben es folglich mit zwei unterschiedlichen Szenarien zu tun.

Gruß
Faber

*) Ereignisfolgen werden im Rahmen der widersprüchlichen SRT als Weltlinien und traditionell als Trajektorien bezeichnet. Im Rahmen der üblichen mathematischen Terminologie sagte man besser: `Ereignisfunktionen'.

[Faber]

@Highway

gamma = 1 / sqrt(1 - v²/c²)

D.h. gamma ist eine Funktion von v und c und sonst von nichts. Da aber sowohl v als auch c gemäß Voraussetzungen konstant sind, ist auch gamma konstant.

Gruß
Faber

[Faber]

Ich habe ein paar kleinere Verbessungern an dem Programm vorgenommen, auch was die Lesbarkeit des Quelltextes angeht.

Blitzgerät und Lichtausbreitung gemäß SRT (v = 0,600c)

LightSphere-c600.gif (465.2 KiB) 6446-mal betrachtet

Blitzgerät und Lichtausbreitung gemäß SRT (v = 0,866c)

LightSphere-c866.gif (460.24 KiB) 6321-mal betrachtet

Datei LightSphere.java:

Code: Alles auswählen

import java.awt.AlphaComposite;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Composite;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.geom.AffineTransform;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Line2D;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;

/**
* Erstellt eine GIF-Datei.
* <p>
* Das animierte Bild zeigt die Ausbreitung eines Lichtblitzes in Form einer Lichtsphäre vom
* Ursprung eines Laborsystems aus sowie die Ausbreitung desselben Lichtblitzes in bezug auf ein zum
* Laborsystem relativ bewegtes, gestrichenes System.
* </p>
* <p>
* Man rufe die {@link #main(String...)}-Methode auf.
* </p>
*
* @author Faber
* @version 1.1
*/
public class LightSphere
{

   /** Breite des Bildes in Pixeln. */
   private final int w = 256 + 128;

   /** Höhe des Bildes in Pixeln. */
   private final int h = 512;

   /** Lichtgeschwindigkeit in m/s. */
   private final double c = 300E6;

   /** Relative Schnelligkeit der Bezugssysteme. */
   private final double v = 0.6 * c;

   /** Gamma-Faktor der Lorentztransformation. */
   private final double gamma = 1.0 / Math.sqrt(1 - (v * v) / (c * c));

   /**
    * Erstellt die Bilddatei.
    *
    * @see #main(String...)
    */
   private LightSphere()
   {

      final String sv = String.format("%.3f", v / c).substring(2);
      final String fileName = String.format("%s-c%s.gif", LightSphere.class.getSimpleName(), sv);
      final AnimatedGifEncoder gifenc = new AnimatedGifEncoder();
      gifenc.setQuality(10);
      gifenc.setRepeat(0);
      gifenc.setDelay(100);
      gifenc.start(fileName);
      final double t0 = 0; // Startzeitpunkt in Sekunden
      final double t1 = 1 / c; // Endzeitpunkt in Sekunden
      final double dt = (t1 - t0) / 50;
      for (double t = t0; t <= t1; t += dt)
      {
         final BufferedImage image = new BufferedImage(w, h, BufferedImage.TYPE_3BYTE_BGR);
         final Graphics2D graphics2D = image.createGraphics();
         try
         {
            { // Hintergrund
               graphics2D.setColor(new Color(0xE0E0E0));
               graphics2D.fillRect(0, 0, w, h);
            }
            { // Bilder
               paint(graphics2D, t, true);
               paint(graphics2D, t, false);
            }
         }
         finally
         {
            graphics2D.dispose();
         }
         gifenc.addFrame(image);
      }
      gifenc.finish();
   }

   /**
    * Malt ein Phasenbild der Animation.
    *
    * @param graphics2D
    *           Grafik-Kontext.
    * @param t
    *           Zeitpunkt in Sekunden.
    * @param labor
    *           Zeigt an, ob in bezug auf das Laborsystem gemalt wird.
    */
   private void paint(final Graphics2D graphics2D, final double t, final boolean labor)
   {

      final int R = h / 4;
      final int mx = 3 * R / 2;
      final int my = labor ? R : 3 * R;
      final double scale = 0.9 * R;
      final double u = 1.0 / scale; // gibt die Breite eines Pixels in Metern an
      final double meterPerDiv = 0.25;
      final AffineTransform transform = new AffineTransform();
      transform.translate(mx, my);
      transform.scale(scale, scale);
      final AffineTransform originalTransform = graphics2D.getTransform();
      try
      {
         graphics2D.setTransform(transform);
         graphics2D.setStroke(new BasicStroke((float) u));
         { // Gitter malen
            graphics2D.setColor(new Color(0xA0A0A0));
            for (double x = -1.0; x <= 1.0; x += meterPerDiv)
            {
               graphics2D.draw(new Line2D.Double(x, -1, x, 1));
            }
            for (double y = -1.0; y <= 1.0; y += meterPerDiv)
            {
               graphics2D.draw(new Line2D.Double(-1, y, 1, y));
            }
         }
      }
      finally
      {
         graphics2D.setTransform(originalTransform);
      }
      { // Achsen und Text malen.
         final int d = 12;
         graphics2D.setColor(Color.BLACK);
         graphics2D.setStroke(new BasicStroke());
         graphics2D.draw(new Line2D.Double(mx + R, my, mx - R, my));
         graphics2D.draw(new Line2D.Double(mx + R - d, my + d, mx + R, my));
         graphics2D.draw(new Line2D.Double(mx + R - d, my - d, mx + R, my));
         graphics2D.draw(new Line2D.Double(mx, my + R, mx, my - R));
         graphics2D.draw(new Line2D.Double(mx - d, my - R + d, mx, my - R));
         graphics2D.draw(new Line2D.Double(mx + d, my - R + d, mx, my - R));
         graphics2D.drawRect(0, my - R, w - 1, 2 * R - 1);
         final Font font = new Font("Verdana", Font.BOLD, 12);
         final String text = String.format("%s = %.3fm\n", labor ? "ct" : "ct'", c * t);
         final Rectangle2D r = font.getStringBounds(text, graphics2D.getFontRenderContext());
         final int th = (int) (r.getHeight() + 0.5);
         final int tw = (int) (r.getWidth() + 0.5);
         graphics2D.setFont(font);
         graphics2D.drawString(String.format("%.2fm/div", meterPerDiv), w - tw - th, my + R - th);
         graphics2D.drawString(text, w - tw - th, my + R - 2 * th);
         if (!labor)
         {
            graphics2D.drawString(String.format("v = %.3fc", v / c), w - tw - th, my + R - 3 * th);
         }
         graphics2D.drawString(labor ? "Laborsystem" : "Gestr. System", th, my - R + th);
         graphics2D.drawString(labor ? "X" : "X'", (int) (mx + scale + 0.5 * th), (int) (my - 0.5 * th));
         graphics2D.drawString(labor ? "Y" : "Y'", (int) (mx + 1.0 * th), (int) (my - scale - 0.0 * th));
      }
      try
      {
         graphics2D.setTransform(transform);
         graphics2D.setStroke(new BasicStroke((float) u));
         final Color color = labor ? new Color(0x00A000) : new Color(0xA00000);
         final double xBlitz = labor ? 0 : -v * t;
         final double yBlitz = 0;
         final int noOfPhotons = 8;
         final double[] xPhoton = new double[noOfPhotons];
         final double[] yPhoton = new double[noOfPhotons];
         { // Photonen berechnen
            for (int k = 0; k < noOfPhotons; k++)
            {
               final double alpha = 2 * Math.PI * k / noOfPhotons;
               xPhoton[k] = labor ? xLabor(alpha, t) : xStrich(alpha, t);
               yPhoton[k] = labor ? yLabor(alpha, t) : yStrich(alpha, t);
            }
         }
         { // Kreis malen.
            final double x = 0;
            final double y = 0;
            final double r = c * t;
            final Composite originalComposite = graphics2D.getComposite();
            try
            {
               graphics2D.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.3f));
               graphics2D.setColor(color);
               graphics2D.draw(new Ellipse2D.Double(x - r, y - r, 2 * r + u, 2 * r + u));
            }
            finally
            {
               graphics2D.setComposite(originalComposite);
            }
         }
         { // Verbindungslinien Blitzgerät-Photonen malen.
            final Composite originalComposite = graphics2D.getComposite();
            try
            {
               graphics2D.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.3f));
               for (int k = 0, N = 8; k < N; k++)
               {
                  final double x = xPhoton[k];
                  final double y = yPhoton[k];
                  {
                     graphics2D.setColor(color);
                     graphics2D.draw(new Line2D.Double(x, y, xBlitz, yBlitz));
                  }
               }
            }
            finally
            {
               graphics2D.setComposite(originalComposite);
            }
         }
         { // Blitzgerät malen.
            final double x = xBlitz;
            final double y = yBlitz;
            {
               final double r = 4 / scale;
               graphics2D.setColor(new Color(0x404040));
               graphics2D.fill(new Rectangle2D.Double(x - r, y - r, 2 * r + u, 2 * r + u));
            }
            {
               final double r = 2 / scale;
               graphics2D.setColor(color);
               graphics2D.fill(new Ellipse2D.Double(x - r, y - r, 2 * r + u, 2 * r + u));
            }
         }
         { // Photonen malen.
            for (int k = 0, N = 8; k < N; k++)
            {
               final double x = xPhoton[k];
               final double y = yPhoton[k];
               {
                  final double r = 3 / scale;
                  graphics2D.setColor(color);
                  graphics2D.fill(new Ellipse2D.Double(x - r, y - r, 2 * r + u, 2 * r + u));
               }
            }
         }
      }
      finally
      {
         graphics2D.setTransform(originalTransform);
      }
   }

   /**
    * Liefert die x-Komponente der Trajektorie eines Photons.
    *
    * @param alpha
    *           Richtung, in die das Photon im Laborsystem vom Ursprung aus fliegt, in Radian.
    * @param t
    *           Zeitpunkt t im Laborsystem, in Sekunden.
    * @return die x-Position des Photons zum Zeitpunkt t in Metern.
    */
   public double xLabor(final double alpha, final double t)
   {

      return c * t * Math.cos(alpha);
   }

   /**
    * Liefert die y-Komponente der Trajektorie eines Photons.
    *
    * @param alpha
    *           Richtung, in die das Photon im Laborsystem vom Ursprung aus fliegt, in Radian.
    * @param t
    *           Zeitpunkt t im Laborsystem, in Sekunden.
    * @return die y-Position des Photons zum Zeitpunkt t in Metern.
    */
   public double yLabor(final double alpha, final double t)
   {

      return c * t * Math.sin(alpha);
   }

   /**
    * Liefert die x'-Komponente der Trajektorie eines Photons.
    * <p>
    * Herleitung siehe <a href="http://www.mahag.com/neufor/viewtopic.php?p=20494#p20494">hier</a>.
    * </p>
    *
    * @param alpha
    *           Richtung, in die das Photon im Laborsystem vom Ursprung aus fliegt, in Radian.
    * @param tStrich
    *           Zeitpunkt t' im gestrichenen System, in Sekunden.
    * @return die x'-Position des Photons zum Zeitpunkt t' in Metern.
    */
   public double xStrich(final double alpha, final double tStrich)
   {

      final double denominator = (c - v * Math.cos(alpha));
      return c * tStrich * (c * Math.cos(alpha) - v) / denominator;
   }

   /**
    * Liefert die y'-Komponente der Trajektorie eines Photons.
    * <p>
    * Herleitung siehe <a href="http://www.mahag.com/neufor/viewtopic.php?p=20494#p20494">hier</a>.
    * </p>
    *
    * @param alpha
    *           Richtung, in die das Photon im Laborsystem vom Ursprung aus fliegt, in Radian.
    * @param tStrich
    *           Zeitpunkt t' im gestrichenen System, in Sekunden.
    * @return die y'-Position des Photons zum Zeitpunkt t' in Metern.
    */
   public double yStrich(final double alpha, final double tStrich)
   {

      final double denominator = (c - v * Math.cos(alpha)) * gamma;
      return c * tStrich * (c * Math.sin(alpha)) / denominator;
   }

   /**
    * Programmeinstiegspunkt.
    *
    * @param args
    *           wird ignoriert.
    */
   public static void main(final String... args)
   {

      new LightSphere();
   }
}


Frohe Weihnacht
Faber

[galactic32]

Begründung: In Gamma steckt ja noch t. Nämlich in v und auch in c. Aber v wird noch im Laborsystem gemessen nach: v = s/t.

Da versteckt sich noch das logische absolute Referenz-System.
In dem diesem Absoluten Koordinaten-System spielt sich das Welt-Scenario in den Einheits-Größen ab.

Faber hat einfach sein Labor-System ins Absolute gepastet.
t=t_labor=t_absolut=1s<>t'=t_K_gestrichen bzw.
gamma(von_System_1,nach_System_2)=gamma(Labor,S')=gamma
gamma(labor,absolut)=1<>gamma(absolut,S')=gamma=1/sqrt(1-v²/c²)
Der Gammafaktor von S' nach Labor ist ja umgekehrt also 1/gamma

Es ist schon richtig, daß
v'=v/gamma
c'=c/gamma,
(Beta=v/c=v'/c' !!!)
denn interpretiert in Worten:
Der Beobachter in S' „sieht“ die Bewegung v, die ein Labor-Beobachter-Meß-Physiker zum Calibrieren vorgibt tatsächlich dann in Zeitraffer im Labor S ,also einen Meter (in s-Metern) mit v(s,t) in der t-Zeit s/v=t-Sekunden in seinen Eigen-Zeit-Messwerten von t'-Sekunden wie der Labor-Zeit-Wert t*gamma .
Oder S' sieht in seiner Eigen-Zeit-Sekunde 1,15 Labor-Zeit-Sekunden (v=0.5 c).

Anders, da die Zeiten in den verschiedenen Systemen i.a. in unterschiedlichem Zeit-Raffer ablaufen braucht es eine neue Referenz-Größe für gamma!
So wie das Ur-Kilogramm ein Ur-Gamma.

Gruß