Message Boards Message Boards

GROUPS:
Staff Picks Wolfram Science Mathematics Optics Physics Graphs and Networks Wolfram Language Wavelets and Fourier Series Wolfram Summer School Wolfram Function Repository Wolfram Fundamental Physics Project
Simon Fischer

[WSS22] Photon propagation through variable-dimensional space

Simon Fischer, Max-Planck Institute for Physics & University of Tuebingen
Posted 11 months ago
5876 Views
|
8 Replies
|
23 Total Likes
|

enter image description here
POSTED BY: Simon Fischer
8 Replies
Sort By:

5-3-23
Dear Professor Fischer,
Great article and congratulations.
Can you extend it in some additional ways - travel through dark matter and dark energy as well?
Near black holes?
Bosonic stars?
And to neutrino travel?

Best wishes,
Paul Shapshak. PhD
University of South Florida

POSTED BY: Paul Shapshak, PhD 
Attributes[SetAmplitudes] = {HoldFirst};
Attributes[TimePropagate] = {HoldFirst};
simpleGridGraph = GridGraph[{32, 32}];
GetAmplitudes[g_] := AnnotationValue[g, VertexWeight];
SetAmplitudes[g_, amplitudes_] := 
  AnnotationValue[g, VertexWeight] = amplitudes;
SetDeltaFunction[g_, vertex_, distance_] := Module[{ng = g},
   (AnnotationValue[{ng, #}, VertexWeight] = 
       ConstantArray[1, Length[#]]) &@
    VertexList[NeighborhoodGraph[g, vertex, distance]];
   ng];
UnnormalizedLaplacian[g_] := 
  N@(DiagonalMatrix[VertexOutDegree[g]] - AdjacencyMatrix[g]) &@
   UndirectedGraph[g];
GraphSpectrum[g_] := <|"eigenvalues" -> Eigenvalues[#],
     "eigenvectors" -> Eigenvectors[#]|> &@
   UnnormalizedLaplacian[g];
EigenSpaceAdvance[spectrum_, coordinates_, t_] := (
    Cos[1/10*t*spectrum["eigenvalues"]] +
     Sin[1/10*t*spectrum["eigenvalues"]]
    )*coordinates;
AmplitudeSpaceAdvance[spectrum_, ic_, t_] := 
  Transpose[spectrum["eigenvectors"]] .
   EigenSpaceAdvance[spectrum, spectrum["eigenvectors"] . ic, t];
TimePropagate[g_, t_] := SetAmplitudes[g,
   AmplitudeSpaceAdvance[GraphSpectrum[g], GetAmplitudes[g], t]];
SetAmplitudes[simpleGridGraph, ConstantArray[0, 1024]];
deltaGridGraph = SetDeltaFunction[simpleGridGraph,
   First[GraphCenter[simpleGridGraph]],
   1];
AmplitudeMatrix2D[g_, n_] := ArrayReshape[
   GetAmplitudes[g],
   {n, n}];
SnowconeColor[z_] := Blend[{
    RGBColor[0, 0, 1],
    RGBColor[1, 1, 1],
    RGBColor[1, 0.4, 0.7]}, z];
animation3DTable = Table[TimePropagate[deltaGridGraph, t];
   ListPlot3D[
    AmplitudeMatrix2D[deltaGridGraph, 32],
    ColorFunction -> SnowconeColor,
    PlotRange -> {
      {1, 32}, {1, 32},
      {-10000, 10000}
      }, BoxRatios -> {1, 1, 0.5}],
   {t, 0, 10, 0.25}];
la = ListAnimate[animation3DTable]

@Simon Fischer When you see the propagation of the transversal EM wave through variable-dimensional space and yeah. I don't know, but you can see it in the intensity of the wave that gets amplified or damped depending on the dimensional change..the recent results in the continuum.

animation3DTable1

simpleGridGraph = GridGraph[{32, 32}];
GetAmplitudes[g_] := AnnotationValue[g, VertexWeight];
Attributes[SetAmplitudes] = {HoldFirst};
SetAmplitudes[g_, amplitudes_] := 
  AnnotationValue[g, VertexWeight] = amplitudes;
SetDeltaFunction[g_, vertex_, distance_] := Module[{ng = g},
   (AnnotationValue[{ng, #}, VertexWeight] = 
       ConstantArray[1, Length[#]]) &@
    VertexList[NeighborhoodGraph[g, vertex, distance]];
   ng];
UnnormalizedLaplacian[g_] := 
  N@(DiagonalMatrix[VertexOutDegree[#]] - AdjacencyMatrix[#]) &@
   UndirectedGraph[g];
GraphSpectrum[g_] := <|"eigenvalues" -> Eigenvalues[#],
     "eigenvectors" -> Eigenvectors[#]|> &@
   UnnormalizedLaplacian[g];
EigenSpaceAdvance[spectrum_, coordinates_, 
   t_] := (Cos[2*t*spectrum["eigenvalues"]])*coordinates;
AmplitudeSpaceAdvance[spectrum_, ic_, t_] := 
  Transpose[spectrum["eigenvectors"]] .
   EigenSpaceAdvance[spectrum,
    spectrum["eigenvectors"] . ic,
    t];
Attributes[TimePropagate] = {HoldFirst};
TimePropagate[g_, t_] := SetAmplitudes[g,
   AmplitudeSpaceAdvance[GraphSpectrum[g],
    GetAmplitudes[g],
    t]];
SetAmplitudes[simpleGridGraph, ConstantArray[0, 1024]];
deltaGridGraph = SetDeltaFunction[
   simpleGridGraph,
   First[GraphCenter[simpleGridGraph]],
   1];
AmplitudeMatrix2D[g_, n_] := ArrayReshape[GetAmplitudes[g], {n, n}];
SnowconeColor[z_] := Blend[{
    RGBColor[0, 0, 1],
    RGBColor[1, 1, 1],
    RGBColor[1, 0.4, 0.7]}, z];
animation3DTable = Table[TimePropagate[deltaGridGraph, t];
   ListPlot3D[
    AmplitudeMatrix2D[deltaGridGraph, 32],
    ColorFunction -> SnowconeColor,
    PlotRange -> {{1, 32}, {1, 32}, {-0.1, 1.2}},
    BoxRatios -> {1, 1, 0.5}],
   {t, 0, 5, 0.1}];
Export["animation3DTable2.gif", animation3DTable]
ListAnimate[animation3DTable]

The best functions were the Laplacian and the ColorByInternalamplitude.

animation3DTable2

Thank you for the Resource function GraphMerge. 

CornerDockingRules[x_, y_, dockingIndex_] := 
  Join[{x*y -> dockingIndex},
   Table[i -> Subscript[v, i], {i, x*y - 1}]];
Create2DGridGraphCorner[x_, y_, dockingIndex_] := 
  Graph[EdgeList[GridGraph[{x, y}]] /. 
    CornerDockingRules[x, y, dockingIndex]];
FaceDockingRules[x_, y_, dockingIndices_] := Join[
   Thread[Table[i, {i, Length[dockingIndices]}] -> dockingIndices],
   Table[i -> Subscript[v, i],
    {i,
     DeleteCases[VertexList[GridGraph[{x, y}]],
      Alternatives @@ dockingIndices]
     }]];
Create2DGridGraphFace[x_, y_, dockingIndices_] := 
  Graph[EdgeList[GridGraph[{x, y}]] /.
     FaceDockingRules[x, y, dockingIndices]];
AppendLowerDimensionGridGraph[highDimensionGridGraph_, 
   lowDimensionGridGraph_] := 
  GraphUnion[highDimensionGridGraph, lowDimensionGridGraph];
highDimensionGridGraph = GridGraph[{7, 7, 7},
   VertexSize -> 0.3,
   VertexStyle -> LightBlue,
   EdgeStyle -> Lighter@Gray];
cornerGraph = Create2DGridGraphCorner[15, 15, 1];
faceGraph = Create2DGridGraphFace[15, 15,
   {1, 2, 3, 4, 5}];
outlandishGraph = AppendLowerDimensionGridGraph[
   AppendLowerDimensionGridGraph[highDimensionGridGraph, 
    cornerGraph],
   faceGraph];
layouts = {"CircularMultipartiteEmbedding", 
   "LayeredDigraphEmbedding",
   "HighDimensionalEmbedding", "SpringElectricalEmbedding",
   "SpringEmbedding", "SpectralEmbedding",};
graphs = Table[
   Graph[outlandishGraph,
    GraphLayout -> layout],
   {layout, layouts}];
Grid[Partition[graphs, 2]]

To observe the effect of fractional dimensionality we can see the chain of the dimensions and the corner and face docking.

GridPhoton1

It's been fun, assigning amplitudes to graph vertices and performing time evolution in the eigenspace of the Laplacian. @Gianmarco Morbelli. 

SierGraph[n_, d_] := 
  MeshConnectivityGraph[SierpinskiMesh[n, d], 0, 
   VertexLabels -> Automatic];
fSier[g_, dockingIndex_, vertexname_] := 
  Join[{{0, 1} -> dockingIndex}, 
   Table[{0, i} -> Subscript[vertexname, i], {i, 
     Length[VertexList[g]]}]];
CreateSierpinskiCorner[n_, d_, dockingIndex_, vertexname_] := 
  Graph[EdgeList[SierGraph[n, d]] /. 
    fSier[SierGraph[n, d], dockingIndex, vertexname]];
sierpinskiCorner = CreateSierpinskiCorner[3, 2, 1, a];
gg = GridGraph[{5, 5}];
g1 = Graph[GraphUnion[gg, CreateSierpinskiCorner[3, 2, 1, b]]];
g2 = Graph[GraphUnion[gg, CreateSierpinskiCorner[4, 2, 1, c]]];
g3 = Graph[GraphUnion[gg, CreateSierpinskiCorner[5, 2, 1, d]]];
g4 = Graph[GraphUnion[gg, CreateSierpinskiCorner[6, 2, 1, e]]];
g5 = Graph[GraphUnion[gg, CreateSierpinskiCorner[7, 2, 1, f]]];
g6 = Graph[GraphUnion[gg, CreateSierpinskiCorner[3, 2, 1, g]]];
g7 = Graph[GraphUnion[g6, CreateSierpinskiCorner[4, 2, 25, h]]];
g8 = Graph[GraphUnion[g7, CreateSierpinskiCorner[5, 2, 25, j]]];
g9 = Graph[GraphUnion[g8, CreateSierpinskiCorner[6, 2, 25, k]]];
g10 = Graph[GraphUnion[g8, CreateSierpinskiCorner[7, 2, 25, l]]];
graphs = {g1, g2, g3, g4, g5, g6, g7, g8, g9, g10}

It was amazing chaining graphs of different dimensions together because that's how we get them chained, @Simon Fischer it's really about different methods of introducing fractional dimensions to a graph, with particles. The associated production of strange particles, quarks, you know.

sierpGraph

You know what it is! The introduction of curvature. 

gridToGraph[gridSize_, {x_, y_}] := 
  With[{theta = 2 Pi x/gridSize, phi = Pi y/gridSize},
   {Cos[theta] Sin[phi], Sin[theta] Sin[phi], Cos[phi]}];
fPertD[g_, vertexname_, pertRadius_] := 
  Table[i -> Subscript[vertexname, i],
   {i, VertexList[
     NeighborhoodGraph[g, First[GraphCenter[g]], pertRadius]]}];
introducePert[g_, pertRadius_, vertexname_] := Graph[EdgeList[g] /.
     fPertD[g, vertexname, pertRadius]];
GG1010 = GridGraph[{10, 10}];
vertexCoordinates = gridToSpherical[10, #] & /@
   (GraphEmbedding[GG1010]);
graph = Graph[VertexList[GG1010],
   EdgeList[GG1010],
   VertexCoordinates -> vertexCoordinates,
   VertexSize -> 0.1,
   EdgeStyle -> Directive[Thickness[0.005]],
   ImageSize -> 500];
perturbedGraph = introducePert[graph, 2, a];
perturbedVertexCoordinates = 
  Thread[VertexList[perturbedGraph] -> gridToGraph[10, #] & /@
    GraphEmbedding[perturbedGraph]];
DirectedGraph[
 Graph[
  perturbedGraph,
  VertexCoordinates -> perturbedVertexCoordinates,
  VertexLabels -> "Name",
  VertexSize -> Thread[VertexList[perturbedGraph] -> Table[
      If[IntegerQ[i],
       0.1,
       0.2],
      {i, VertexList[perturbedGraph]}]],
  VertexStyle -> Thread[VertexList[perturbedGraph] -> Table[
      If[IntegerQ[i],
       RGBColor[0.4, 0.8, 1],
       RGBColor[1, 0.6, 0.8]],
      {i, VertexList[perturbedGraph]}]],
  EdgeStyle -> Directive[Thickness[0.001]],
  ImageSize -> 500]]
Graphics3D[{
  Opacity[0.5],
  RGBColor[0.4, 1, 0.6],
  Line[{{0, 0, 0}, #}] & /@
   (perturbedVertexCoordinates[[All, 2]])}]

When we get these graphs all solved out it's like introducing curved graphs, the propagation of an electromagnetic wave on a 2D grid graph, with a light flash originating from the center of a sphere.

perturbationGraph1

I saw the differential spatial spread sound in the center of the wave, and in its wake it's like how proper time is not a local nor global concept; it is rather associated to a specific reference frame (a priori of arbitrary size).

perturbationGraph2

This is so observer-centric. But that's just the graph. @Simon Fischer. 

Plot[{
  (Re[x^(1 - (1.585)/2) HankelH2[3, x]] + Re[HankelH2[3, x]])*
   Sin[2*Pi*x],
  (Re[x^(1 - (2.3)/2) HankelH2[3, x]] + Re[HankelH2[3, x]])*
   Sin[2*Pi*x]},
 {x, 0, 10},
 PlotStyle -> {
   Directive[RGBColor[0.4, 0.8, 1], Thick],
   Directive[RGBColor[1, 0.6, 0.3], Thick]
   },
 ImageSize -> Large,
 AxesLabel -> {"Radial distance r [a.u.]", "Amplitude [V/m]"},
 PlotLegends -> "Expressions"]

When you see what happened with the compact-closed dagger symmetric monoidal categories..

Radial Distance

@Simon Fischer? 

Getamplitudes[g_] := AnnotationValue[g, VertexWeight];
Attributes[Setamplitudes] = {HoldFirst};
Setamplitudes[g_, amplitudes_] := 
  AnnotationValue[g, VertexWeight] = amplitudes;
GraphDistSmooth[g_, v1_, v2_] := 
  If[String[v1] === String[v2], 1, GraphDistance[g, v1, v2]];
d[g_, v_, perturbedDimension_] := 
  If[IntegerQ[v], 2, perturbedDimension];
Phi[g_, vCenter_, v2_, t_, v_, beta_, perturbedDimension_] := 
  2*GraphDistSmooth[g, vCenter, 
     v2]^(1 - (d[g, v2, perturbedDimension])/2) HankelH2[v, 
    beta*GraphDistSmooth[g, vCenter, v2]]*Cos[t];
newVertexValuesFracDim[g_, v1_, t_, q_, c_, perturbedDimension_] := 
  Table[Re[Phi[g, v1, it, t, q, c, perturbedDimension]],
   {it, VertexList[g]}];
AmplitudeMatrix3D[g_, n_] := ArrayReshape[Getamplitudes[g], {n, n, n}];
SnowconeColor[z_] := Blend[{RGBColor[0, 0, 1],
    RGBColor[1, 1, 1],
    RGBColor[1, 0.4, 0.7]}, z];
GG101010 = GridGraph[{10, 10, 10},
   VertexShapeFunction -> "Circle",
   VertexSize -> Large];
animation3DTableGG = Table[Setamplitudes[GG101010,
    newVertexValuesFracDim[GG101010,
     First[GraphCenter[GG101010]],
     t, 0.3, 1, 3]];
   ListPlot3D[AmplitudeMatrix3D[GG101010, 10],
    ColorFunction -> SnowconeColor,
    PlotRange -> {{1, 10}, {1, 10}, {-2, 2}},
    BoxRatios -> {1, 1, 1}], {t, 0, 7, 0.5}];
ListAnimate[animation3DTableGG]

The graph formats..maybe there are other ways to render them.

animation3DTableGG

Maybe we can render them on Android. Like how we found common ground between us, was really foundational. 

With[{gg = GridGraph[{10, 10, 10}, VertexShapeFunction -> "Circle"]}, 
  perturbedGraph3D = 
   Graph[introducePert[gg, 3, a], 
    VertexSize -> 
     Thread[VertexList[introducePert[gg, 3, a]] -> 
       Table[If[IntegerQ[i], 3, 5], {i, 
         VertexList[introducePert[gg, 3, a]]}]]]];
newVertexValuesFracDim[g_, v1_, t_, q_, c_, perturbedDimension_] := 
  Table[Re[Phi[g, v1, it, t, q, c, perturbedDimension]],
   {it, VertexList[g]}];
animation3DTableGGpertD = Table[
   Setamplitudes[perturbedGraph3D,
    newVertexValuesFracDim[perturbedGraph3D, 
     First[GraphCenter[perturbedGraph3D]],
     t, 0.3, 1, 2.4]];
   ListPlot3D[
    AmplitudeMatrix3D[perturbedGraph3D, 10],
    ColorFunction -> SnowconeColor,
    PlotRange -> {{1, 10}, {1, 10}, {-1, 1.5}},
    BoxRatios -> {1, 1, 1}],
   {t, Table[i, {i, 0, 6.5, 0.5}]}];
ListAnimate[
 Rasterize[#, RasterSize -> 400] & /@ animation3DTableGGpertD]

Thank you for this. So now you know the analytic solution for the wave equation, in the order that it happens.

animation3DTableGGpertD

SierGraph[n_, d_] := 
  MeshConnectivityGraph[SierpinskiMesh[n, d], 0, 
   VertexLabels -> Automatic];
fSier[g_, dockingIndex_, vertexname_] := Join[{{0, 1} -> dockingIndex},
   Table[{0, i} -> Subscript[vertexname, i],
    {i, Length[VertexList[g]]}]];
CreateSierpCorner[n_, d_, dockingIndex_, vertexname_] := Graph[
   EdgeList[SierGraph[n, d]] /.
     fSier[SierGraph[n, d],
     dockingIndex,
     vertexname]];
TableOfSierps[sierpx_, sierpDim_, firstDockingIndex_, 
   lastDockingIndex_] := Table[
   CreateSierpCorner[sierpx, sierpDim, a,
    ToString[Part[Alphabet[], a - firstDockingIndex + 1]] <>
     ToString[firstDockingIndex]],
   {a, firstDockingIndex, lastDockingIndex}];
Getamplitudes[g_] := AnnotationValue[g, VertexWeight];
Attributes[Setamplitudes] = {HoldFirst};
Setamplitudes[g_, amplitudes_] := 
  AnnotationValue[g, VertexWeight] = amplitudes;
ColorByamplitude[g_, amplitudes_] := 
  HighlightGraph[g, 
   MapThread[
    Style, {VertexList[g], Map[ColorData["Rainbow"], amplitudes]}]];
ColorByInternalamplitude[g_] := 
  ColorByamplitude[g, Getamplitudes[g]];
UnnormalizedLaplacian[g_] := 
  N@(DiagonalMatrix[VertexOutDegree[#]] - AdjacencyMatrix[#]) &@
   UndirectedGraph[g];
GraphSpectrum[
   g_] := <|"eigenvalues" -> Eigenvalues[#], 
     "eigenvectors" -> Eigenvectors[#]|> &@
   UnnormalizedLaplacian[g];
EigenSpaceProject[ic_, eigenvectors_] := eigenvectors . ic;
VertexSpaceProject[vector_, eigenvectors_] := 
  Transpose[eigenvectors] . vector;
EigenSpaceAdvance[spectrum_, coordinates_, 
   t_] := (Cos[1/10*t*spectrum["eigenvalues"]] +
     Sin[1/10*t*spectrum["eigenvalues"]])*coordinates;
amplitudeSpaceAdvance[spectrum_, ic_, t_] := VertexSpaceProject[
     EigenSpaceAdvance[spectrum, EigenSpaceProject[ic, #], t], #] &@
   spectrum["eigenvectors"];
Attributes[TimePropagate] = {HoldFirst};
TimePropagate[g_, t_] := 
  Setamplitudes[g, 
   amplitudeSpaceAdvance[GraphSpectrum[g], Getamplitudes[g], t]];
SetDeltaFunction[g_, vertex_, distance_] := Module[{ng = g},
   (AnnotationValue[{ng, #}, VertexWeight] = 
       ConstantArray[1, Length[#]]) &@
    VertexList[NeighborhoodGraph[g, vertex, distance]];
   ng];
ThreeDGG = GridGraph[{10, 10, 10},
   VertexSize -> 6,
   VertexShapeFunction -> "Circle",
   ImageSize -> 400, VertexLabels -> Automatic];
t1 = TableOfSierps[3, 2, 1, 10];
t2 = TableOfSierps[3, 2, 91, 100];
finalChained3D = 
  Graph[GraphUnion[GridGraph[{10, 10, 10}], t1[[5]], t2[[5]]],
   ImageSize -> 400,
   VertexShapeFunction -> "Circle",
   VertexSize -> 6];
Setamplitudes[finalChained3D,
  ConstantArray[0, Length[VertexList[finalChained3D]]]];
ColorByInternalamplitude[finalChained3D];
deltaGridGraph3DSierp = SetDeltaFunction[finalChained3D,
   First[GraphCenter[GridGraph[{10, 10, 10}]]], 1];
ColorByInternalamplitude[deltaGridGraph3DSierp];
animation3DTableSierp = Table[
   TimePropagate[deltaGridGraph3DSierp, t];
   ColorByInternalamplitude[deltaGridGraph3DSierp],
   {t, Table[i, {i, 0, 30, 1}]}];
ListAnimate[
 Rasterize[#, RasterSize -> 400] & /@ animation3DTableSierp]

What we focus on is adding our own edges, which might explain the spatial behavior of the wave in cases where the dimension is less than or greater than two.

animation3DTableSierp

In that sense we can switch places from the 3D to the Simon Fischer 2D grid graph, this is the place to be.

simpleGridGraph = GridGraph[{10, 10, 10},
   ImageSize -> 400,
   VertexSize -> 6,
   VertexShapeFunction -> "Circle"];
simpleGridGraph = EdgeAdd[simpleGridGraph,
   {529 <-> 500, 529 <-> 498, 529 <-> 558, 529 <-> 560, 529 <-> 561,
    529 <-> 501, 529 <-> 497, 529 <-> 557, 529 <-> 590, 529 <-> 588,
    529 <-> 620, 529 <-> 618, 529 <-> 470, 529 <-> 440, 529 <-> 468, 
    529 <-> 438}];
Setamplitudes[simpleGridGraph, ConstantArray[0, 1000]];
ColorByInternalamplitude[simpleGridGraph];
deltaGridGraphLocalPert = SetDeltaFunction[simpleGridGraph, 259, 1];
ColorByInternalamplitude[deltaGridGraphLocalPert];
TimePropagate[deltaGridGraphLocalPert, 0];
ColorByInternalamplitude[deltaGridGraphLocalPert];
animation3DTableLocalPert = 
  Table[TimePropagate[deltaGridGraphLocalPert, t];
   ColorByInternalamplitude[deltaGridGraphLocalPert],
   {t, Table[i, {i, 0, 16, 0.5}]}];
ListAnimate[Rasterize[#, RasterSize -> 400] & /@
  animation3DTableLocalPert]

I just show that the intensity of the wave gets amplified or damped whatever the dimensional shape. With these high-energy particles..we've got these electron-positron pairs, charge -1 and +1, and there's a cloud of electrons and positrons around the electron which in some sense will screen the charge of the electron, roughly.

animation3DTableLocalPert

edAddFct[g_] := 
 Sort /@ UndirectedEdge @@@ 
      Position[Outer[EuclideanDistance@## &, #, #, 1], N@Sqrt@3] &@
   GraphEmbedding@g // Union
AddCrossBars[g_] := EdgeAdd[g, edAddFct[g]]
simpleCrossGraph = EdgeAdd[GridGraph[{10, 10, 10},
    ImageSize -> 400,
    VertexSize -> 6,
    VertexShapeFunction -> "Circle"],
   edAddFct[GridGraph[{10, 10, 5}]]];
Setamplitudes[simpleCrossGraph,
  ConstantArray[0, Length[VertexList[simpleCrossGraph]]]];
ColorByInternalamplitude[simpleCrossGraph];
deltaGGCrossBar = SetDeltaFunction[simpleCrossGraph, 500, 1];
ColorByInternalamplitude[simpleCrossGraph];
animation3DTableCross = Table[TimePropagate[deltaGGCrossBar, t];
   ColorByInternalamplitude[deltaGGCrossBar],
   {t, Table[i, {i, 0, 16, 0.5}]}];
ListAnimate[animation3DTableCross]

These are quite some models for fractional dimensional shape.

animation3DTableCross

Fractional dimensions can cause damping or amplifying effects on the amplitude of EM waves, exploring the concept of curvature and modeling non-integer, spatial dimensions..this graph is particularly electrifying at the least. I see the Simon Fischer resource functions for heterodimensional graphs, arbitrary wave equations, and grid graphs with crossbars. Yeah, I would like to express gratitude to you Simon for what happened between us and for supervising part of my project, with support and encouragement from Stephen Wolfram. The photon can carry momentum.

POSTED BY: Dean Gladish

Great work and very exciting findings!! I am looking forward to see further developments of the project Simon!
POSTED BY: Gianmarco Morbelli

Thanks Gianmarco! Was a great summer school and I was blessed to work with you!
POSTED BY: Simon Fischer
Chase Marangu
Chase Marangu
Posted 11 months ago

Photon propagation through Sierpinski graph was awesome! Another name for the 3D Sierpinski Tetrahedron is the Tetrix (https://en.wikipedia.org/wiki/Sierpi%C5%84ski_triangle)
POSTED BY: Chase Marangu

Thanks Chase! That's interesting, didn't know that - Will have a look, thank you :)
POSTED BY: Simon Fischer

enter image description here -- you have earned Featured Contributor Badge enter image description here Your exceptional post has been selected for our editorial column Staff Picks http://wolfr.am/StaffPicks and Your Profile is now distinguished by a Featured Contributor Badge and is displayed on the Featured Contributor Board. Thank you!
POSTED BY: Moderation Team

Any comments / discussions are welcome:)
POSTED BY: Simon Fischer
Reply to this discussion
Community posts can be styled and formatted using the Markdown syntax.
Tag limit exceeded
Note: Only the first five people you tag will receive an email notification; the other tagged names will appear as links to their profiles.
Reply Preview
Attachments
Remove
or Discard

Group Abstract Group Abstract