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.

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
.

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.

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.

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.

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).

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..

@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.

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.

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.

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.

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.

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.