下面考虑质数螺旋
曾经以1开始绘制螺旋图，但是计算质数坐标的时候就出现困难。所以我们用0开始，并把它放在螺旋的中心。
观察如下图像，
最中心的数字0，不算大小。圈数为
，对应的数的个数，也就是面积为，
这些圈的最小值是0，最大值是，
相邻两项的差为，
这是一个二阶等差数列，对应的数值的和为，
这些数值，并不关心旋转的起点。仔细观察我们发现这些质数构成的线都几乎都是对角线，相当于旋转了45°的结果，既然如此，我们把起点旋转45°，看看能不能把斜线变成横竖的直线。
这是旋转45°之后的表格的样子。不难发现，中心行或者列上都是偶数，除了2是质数之外，不可能再有别的质数。所以就算是旋转45°之后，斜角上的数会落在横向和纵向的连线上，也不可能发生在中间的横轴或者纵轴上。而所有可能的连线都在这些轴的平行线上。
按照这个模式，用程序实现巨大范围内的质数螺旋效果，如上图所示。可见斜线已经被纠正为横线和竖线。质数的存在密度确实是中间更高。这个图像缩小之后，出现明显的十字图案，
这个图像的2D-FFT如下图中间部分所示，
其中最中心有一个亮点，其它位置上确实都是0，这通常说明图像极其简单，无任何结构或者纹理。但是实际上是有清晰的横纹和纵纹的，出现这种结果，说明指数在这个前提下的分布规律至少是可以不显露模式的。这也是质数的规律难于掌握的体现。
如果四个象限的坐标各自同时翻转（x横向翻转，y同时纵向翻转），则可以得到如下图像，
将图像缩小一定的比例之后，出现非常明显的圈层图案，
对四个象限，各自都上下左右翻转，这个做法本质上就是掉转计数的方向。因为是二维平面上的排列，所以才有四个象限，也就是2的平方。我们把这个维数降维到一维，其实就是观察一个象限里面的情况，在一个象限中，上下和左右同时翻转，对应的就是一维情况中的前后翻转，比如第一个质数被放在最后，最后一个质数被放在最前。一维情况下的闭合，就是出现周期性，二维情况下的闭合，需要把四个象限拼合在一起，而单个象限中就会出现拐角的形态，以使得两个维数可以互通为一个维数。这些情况，在这个图片中都显现了出来。另外单个象限中拐角图案不止一个，说明拐角构成的闭环不止一个，说明图片中含有的周期也不止一个。而这些周期，必然可以回归到它的一维形态，因为这些数，本来就是"卷起来的"，所以这些圈也不可能彼此孤立，而是首尾相接，构成整体上的离散螺线。这些情况也在这个图片中体现出来了。回到最初，我们是把自然数，从0开始，一直绕着0环绕，构成了整个图像，并且把其中的质数都标成白色。现在，我们通过把四个象限各自翻转，进而把整个周期都翻转过来，发现那些被标成白色的质数，聚会在一起，反而出现了螺旋的形态。只是原来的螺旋是一个数一个数构成的螺旋，现在的螺旋是一大堆质数形成一个微小线段，再由这些微小线段构成螺旋。这就相当于，原来的一个自然数，由现在的一大堆数值要大的多的质数拟合而成。而这些拟合成的不再是分立的自然数，而是连续的实数，因为这些用于拟合数量的质数，并不精确的构成整数。
所以这时候，同样的点，实际上是相对于整个图片存在的，相当于构成那个自然数的，是若干质数之和。而最开始的自然数螺旋，单个点就是单个质数本身。
相对于整个图片说的就是单位1，而单位1又分为质数基于的单位1和基于质数的单位1，也就是类似于
和
。由这一点去理解，就可以认识到质数和自身的倒数的等价性，这种等价性至多含有一个不为1的比例常数，
将这个比例常数
吸收到
和
的比例之中，或者将
和
的比例吸收到
里面即可得到，
那么，为什么不是，
或者说，为什么质数不是像
那样的虚数单位，这可以从我们用同时反转横向和纵向的做法中看出来。所以质数对应的是它所在周期的-1，而质数的平方根才是它所在周期的虚数单位。从，
中可以导出，
从
和
的实际值来说，显然一个是单位1的巨大倍数也就是
和单位1本身也就是
，也就是，
但是由于最终的关系体现为，
而，
导致结果必然体现出，
也就是数值上的，
这就是一种由于观测导致的必然的假象。这也是为什么，不能通过向外探查而了解真相的原因。向外探查了解真相就相当于要反向绕地球一圈才能到达一步就可以去到的地方。如果引入虚数单位，我们显然还是得把基本的当作1，把数量更大的当作虚数单位，
但是虚数单位和自身负倒数相等的关系同样会使得
和
之间的大小失去确定性，
就像狭义相对论分不清到底哪个才是主动引发运动的惯性系一样，在以测量为标准的系统中，
和
到底谁大谁小，是没法知道的。这是一切混淆得以成立的原因，也是为什么必须得自己成为才能真正理解的原因。在物理世界中，一切皆可互相颠倒，人却浑然不知，也是这个原因：观察者观测所观之物，必然导致这个结果。而如何才能纠正这种潜在的错误，唯一的方法就从自身的经验去验证。这也是实践是检验真理的唯一标准的一种脚注。也是做人做事必须摸着自己的良心来办，才能说人话办人事，而不是成为"人类的叛徒"的原因。因为你自己就是，你就错不了，你错了你自己会先知道，而如果抄别人的，拿来主义，最后你自己都不知道你干的是什么。所以那些真正实践的人，才是真理的真正掌握者，但这真理无法言说，说出来之后，听的人就成了被动观测者，可是观测者角色本身就有倒置世界而产生错误的严重问题，所以如果观测者不理解这一点，那么他会把所有的事情都理解反了，而如果继续按照这种认知来做出选择，他一定会走上反人类的道路。这也是普鲁士教育造成大规模的认知缺陷的根本原因。一个更为严峻的问题就是精神病的治疗问题，精神科医生普遍没有精神病的经历，和感冒发烧大家都有经历完全不同。医生没有病人的经历，就成了纯粹的观察者，但只要是观察者，观察到的和实际的情况就是相反的，如果他不能从人本的角度出发意识到病人也是人，他就会做出为了治病而治病，甚至为了治病而要命的判断和选择，这一点不是谁的错，而是任何人都做不到。就算是他能自认为感同身受的去体谅，因为没有精神病的经验，仍然会把事情干错。而病人本身又没有相关的医学知识，再被错误的对待，结果就会活在没人知道为什么的身心地狱之中。那种把书本上的知识当作前人的经验而不基于自己的经验的做法，是根本上行不通，甚至是要命的。这也是为什么优级主义看上去很美好，但实际上始终在作恶的原因。都是一个原因，就是观察者不合格，没有处理好观察和对观察的理解的转换过程，也没有处理好理解和传播的转换过程，而后者则是传播者不合格的体现。
虚数单位是怎么来的？虚数单位就是计数能力的极限的体现，也就是说，观察者受到的限制的在数学上的体现。所以观察者不合格是必然的，因为只要有观察者，观察者的上限不是定值，总有更大的数值，也总有更小的数值。所以观察者总有一天会不合格，也就是说，观察者自身的能力极限对应的环绕特性会把
看成，
也就是把世界看成颠倒的样子，并顺着这个结论，做出完全相反的选择。
如何超越？只有一个选项，就是认识到
和
的存在，以及二者大小的相对性。用人话来说，就是意识到有不同的人，人有强有弱，但是总有更强和更弱，于是这种比较就是没有确定结果的，没有确定结果就没有追求的价值，追求错误的东西，就只能徒增烦恼，甚至伤害他人。而一旦认定确定结果，就有可能完全看反，因为观察者总是不合格，也永远不可能合格，因为观察者是相对于非观察者才能成立的概念。可是这只是概念，谁都是观察者，谁都不是观察者。所以讨论一个并不能稳定成立的概念，并追求结果可以合格，完全就是妄想。
结论也很简单，有些东西学得了，有些东西学不了。成就一个人的是自己的经验，而获得经验的最基本要求，是不伤害别人，其次是避免阻止他人获得经验。无论何种原因和何种方式。但这一样太难，看着你的亲友挚爱去送死，一个人怎么才能狠心做到。这就是一环扣有一环的逻辑锁。而当你看到这一点，你也就明白了这个问题的解。但是这句话是无用的，你仍然活在自己的经验造成的观念里。
所以忘了这些，凭着你自己的良心生活，走那条难但是不退转的路，也许就是最终唯一的答案。
现代社会的高度发达，是基于分工的，分工创造了丰裕，也创造了大量的价值。
但分工有一个严重的弊端，就是你可能不得不把非常重要的东西交到别人手里，比如财富，比如自由，更比如生命。这些东西交给别人，正常来说需要极大的信任，但是这个信任也是有条件的，最基本的条件，就是不能背叛，还有就是不能脱离人本。当你把自己的生命交给一个你认为可信的人，而他在背后为了自己的利益而不顾你的死活，这个社会就没法运行下去。天堂就一夜之间变成了地狱。而信任是双向的，双向的信任基于最基本的互相理解，互相理解则基于共同的生活，可是分工本来就意味着不同的生活。在不同的生活里面失去基本的互相理解，进而轻易的就会失去信任关系，这又是一个逻辑上的死结。假定信任关系存在，又被愚弄和背叛，而信任关系不存在，则又失去了繁荣的基础，这又是一个死结。
既有分工的繁荣，又不会失去信任，信任又不被欺诈利用，所有这些条件都是现代社会可以安全稳定高效运行的基础。实际上的要求更多，这几点完全不能涵盖其全部，但都可以归结为认知问题。然而认知又天生就有观察者效应造成相反效果的极大的概率。
所以这是世界上最难的问题之一，不是解决不了或者解决得了，而是问不出来，甚至是想不起问。
但是，但是，你如果按照你本心的善良去做，而不是按照利益去做，你就根本不需要问。
这就是所谓一步就能走到的，却要绕过整个地球才能到达的问题。
以及走那么远到底值得不值得的问题。
我不想再替你回答，你自己能理解，自己就能办好，于是，被动观察者的帽子，就不用给你戴了。
把这个破事，总结以下，起个名字，就叫"认知基本定理"：在观测过程中，观察者所得的观测信息，总是和所观之物的实际情况相反（包括但不限于倒数和相反数）。若要得到正确的认识，最佳的方法就是成为所观之物本身。
应用到社会生活中：你想要帮助一个或者一群人，你首先要成为他们的一份子，了解他们真实的生活，然后再跳出来，找到问题的解答，然后再跳回去验证解答的正确性（当然不是慷他人之慨），然后再跳出来，反反复复，若干次迭代之后，自会有所成效。
所以反过来再看，比如比尔盖茨去非洲扶贫，为什么会越扶越贫，殖民者总是认为给殖民地带来了文明，却在实际上剥夺了殖民地自身发展而不依赖外界的基本条件。就像为什么一个人要自己站稳，环境不是给他结果，而是给他站稳的条件，为什么授人以鱼不如授人以渔，都是这个原因，你不是他，你办不了他的事，你是他，你就和他一样救不了自己。所以你是他，你也不是他，你真正愿意去感同身受，而且真的知道自己在干什么，才不会落得帮人的人把人坑死的下场 。所以你看，不是没有救世主，也不是没有神仙皇帝，有啥都没用，不会干，把事情干反了，违背规律，就是这个结果。这也从侧面验证了，一个好的环境，一个以人为本的环境，才是解脱苦难的唯一出路。
以下为最新完整的程序代码
cs
using System.Drawing.Imaging;
using System.Numerics;
namespace PrimeCross;
public partial class FormMain : Form
{
public static Bitmap GetBitmap(int[,] pixels)
{
var width = pixels.GetLength(0);
var height = pixels.GetLength(1);
var bitmap = new Bitmap(width, height);
using var g = Graphics.FromImage(bitmap);
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
int pixel = pixels[x, y];
pixel |= unchecked((int)0xff000000);
var c = Color.FromArgb(pixel);
bitmap.SetPixel(x, y, c);
}
}
return bitmap;
}
public static int[,] GetPixels(Bitmap bitmap)
{
int width = bitmap.Width;
int height = bitmap.Height;
var pixels = new int[width, height];
var rect = new Rectangle(0, 0, width, height);
var data = bitmap.LockBits(rect, ImageLockMode.ReadOnly, bitmap.PixelFormat);
int bytesPerPixel = Image.GetPixelFormatSize(bitmap.PixelFormat) / 8;
int bytes = Math.Abs(data.Stride) * height;
var rgbValues = new byte[bytes];
System.Runtime.InteropServices.Marshal.Copy(data.Scan0, rgbValues, 0, bytes);
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
int i = y * data.Stride + x * bytesPerPixel;
var v = rgbValues[i] | (rgbValues[i + 1] << 8) | (rgbValues[i + 2] << 16) | (rgbValues[i + 3] << 24);
pixels[x, y] = v;
}
}
bitmap.UnlockBits(data);
return pixels;
}
public static void FFT(Complex[] t, Complex[] f, int r)
{
long count = 1 << r;
int i, j, k, p, bsize;
var W = new Complex[count >> 1];
var X1 = new Complex[count];
var X2 = new Complex[count];
for (i = 0; i < W.Length; i++)
{
var angle = i * Math.PI * 2 / count;
W[i] = new(Math.Cos(angle), -Math.Sin(angle));
}
t.CopyTo(X1, 0);
for (k = 0; k < r; k++)
{
for (j = 0; j < 1 << k; j++)
{
bsize = 1 << (r - k);
for (i = 0; i < bsize / 2; i++)
{
p = j * bsize;
X2[i + p]
= X1[i + p] + X1[i + p + bsize / 2]
;
X2[i + p + bsize / 2]
= (X1[i + p] - X1[i + p + bsize / 2])
* W[i * (1 << k)]
;
}
}
(X1, X2) = (X2, X1);
}
for (j = 0; j < count; j++)
{
p = 0;
for (i = 0; i < r; i++)
{
if ((j & (1 << i)) != 0)
{
p += 1 << (r - i - 1);
}
}
f[j] = X1[p];
}
}
public static Bitmap Fourier(Bitmap bitmap)
{
int width = bitmap.Width;
int height = bitmap.Height;
long lw = 1;
long lh = 1;
int wp = 0;
int hp = 0;
long i, j;
long n, m;
double kt;
var data = GetPixels(bitmap);
while (lw * 2 <= width)
{
lw *= 2;
wp++;
}
while (lh * 2 <= height)
{
lh *= 2;
hp++;
}
var t = new Complex[lw * lh];
var f = new Complex[lw * lh];
var tw = new Complex[lw];
var th = new Complex[lw];
for (i = 0; i < lh; i++)
{
for (j = 0; j < lw; j++)
{
t[i * lw + j] = new(data[j, i] == 0 ? 0 : 0xffffff, 0.0);
}
}
for (i = 0; i < lh; i++)
{
Array.Copy(t, i * lw, tw, 0, lw);
Array.Copy(f, i * lw, th, 0, lw);
FFT(tw, th, wp);
Array.Copy(th, 0, f, i * lw, lw);
}
for (i = 0; i < lh; i++)
{
for (j = 0; j < lw; j++)
{
t[j * lh + i] = f[i * lw + j];
}
}
var ow = new Complex[lh];
var oh = new Complex[lh];
for (i = 0; i < lw; i++)
{
Array.Copy(t, i * lh, ow, 0, lh);
Array.Copy(f, i * lh, oh, 0, lh);
FFT(ow, oh, hp);
oh.CopyTo(f, i * lh);
}
var max = f.Max(c => (c.Magnitude));
for (i = 0; i < lh; i++)
{
for (j = 0; j < lw; j++)
{
var val = f[j * lh + i].Magnitude;
kt = (val / max) * 255.0;
n = (height - lh) / 2 + (i < lh / 2 ? i + lh / 2 : i - lh / 2);
m = (width - lw) / 2 + (j < lw / 2 ? j + lw / 2 : j - lw / 2);
data[m, n] = Color.FromArgb(
(byte)kt,
(byte)kt,
(byte)kt)
.ToArgb();
}
}
return GetBitmap(data);
}
public FormMain()
{
InitializeComponent();
}
private enum Direction : int
{
Down = 0,
Right,
Up,
Left
}
private static Direction Turn(Direction d, bool left = true) => left
? (Direction)(((int)d + 1) % 4)
: (d == Direction.Down) ? Direction.Left : ((Direction)((int)d) - 1)
;
private static Point LeftOf(Point p, Direction d) => d switch
{
Direction.Down => new(p.X + 1, p.Y),
Direction.Right => new(p.X, p.Y - 1),
Direction.Up => new(p.X - 1, p.Y),
Direction.Left => new(p.X, p.Y + 1),
_ => p,
};
private static Point RightOf(Point p, Direction d) => d switch
{
Direction.Down => new(p.X - 1, p.Y),
Direction.Right => new(p.X, p.Y + 1),
Direction.Up => new(p.X + 1, p.Y),
Direction.Left => new(p.X, p.Y - 1),
_ => p,
};
private static Point ForwardOf(Point p, Direction d) => d switch
{
Direction.Down => new(p.X, p.Y + 1),
Direction.Right => new(p.X + 1, p.Y),
Direction.Up => new(p.X, p.Y - 1),
Direction.Left => new(p.X - 1, p.Y),
_ => p,
};
private static bool IsPrime(long n)
{
switch (n)
{
case < 2:
return false;
case 2:
return true;
}
if (n % 2 == 0) return false;
for (long i = 3; i <= Math.Sqrt(n); i += 2)
if (n % i == 0) return false;
return true;
}
const int Black = 0x000000;
const int White = 0xffffff;
const int Red = 0x0000ff;
bool flip = false;
bool inverse = false;
bool rotate = false;
int length = 0;
(int, long, bool)[,]? primes = null;
private static (int, long, bool)[,] BuildPrimesMap(int length)
{
var map = new (int, long, bool)[length, length];
var center = new Point(length >> 1, length >> 1);
var direction = Direction.Up;
long n = 0;
map[center.X, center.Y] = (White, n++, false);
var p = new Point(center.X + 1, center.Y + 1);
map[p.X, p.Y] = (Red, n++, false);
p.Y--;
map[p.X, p.Y] = (White, n++, true);
while (n <= length * length)
{
n++;
p = ForwardOf(p, direction);
if (p.X < 0 || p.X >= length - 1
|| p.Y < 0 || p.Y >= length - 1)
break;
var b = IsPrime(n);
map[p.X, p.Y] = (b ? White : Red, n, b);
var l = LeftOf(p, direction);
if (l.X < 0 || l.X >= length - 1
|| l.Y < 0 || l.Y >= length - 1)
break;
var lc = map[l.X, l.Y];
if (lc.Item1 == Black)
{
direction = Turn(direction);
}
else
{
var pt = ForwardOf(p, direction);
if (pt.X < 0 || pt.X >= length - 1
|| pt.Y < 0 || pt.Y >= length - 1)
continue;
var px = map[pt.X, pt.Y];
if (px.Item1 != Black)
{
var rp = RightOf(p, direction);
if (rp.X < 0 || rp.X >= length - 1
|| rp.Y < 0 || rp.Y >= length - 1)
break;
p = rp;
}
}
}
return map;
}
private static Point FlipProject(Size size, Point p, bool flip = false, bool rotate = false)
{
var cp = new Point(size.Width >> 1, size.Height >> 1);
if (!flip)
{
return rotate ? new(p.Y, p.X) : p;
}
else
{
int x = p.X, y = p.Y;
x = x < cp.X ? cp.X - x : size.Width + (cp.X - x) - 1;
y = y < cp.Y ? cp.Y - y : size.Height + (cp.Y - y) - 1;
return rotate ? new(y, x) : new(x, y);
}
}
private void GeneratePrimesMap(bool flip = false, bool inverse = false, bool rotate = false)
{
this.primes = BuildPrimesMap(
this.length = Math.Max(
PrimesPictureBox.Width,
PrimesPictureBox.Height)
);
var bitmap = new Bitmap(PrimesPictureBox.Width, PrimesPictureBox.Height);
var size = new Size(PrimesPictureBox.Width, PrimesPictureBox.Height);
for (int y = 0; y < size.Height; y++)
{
for (int x = 0; x < size.Width; x++)
{
var px = x + ((this.length - PrimesPictureBox.Width) >> 1);
var py = y + ((this.length - PrimesPictureBox.Height) >> 1);
var c = this.primes[px, py];
var fp = FlipProject(size, new Point(x, y), flip, rotate);
bitmap.SetPixel(fp.X, fp.Y,
((!inverse) ? c.Item3 : !c.Item3) ? Color.White : Color.Black);
}
}
this.PrimesPictureBox.Image?.Dispose();
this.PrimesPictureBox.Image = bitmap;
}
private void Reset()
{
this.GeneratePrimesMap(this.flip = false, this.inverse = false, this.rotate = false);
}
private void Flip()
{
this.GeneratePrimesMap(this.flip = !this.flip, this.inverse, this.rotate);
}
private void Inverse()
{
this.GeneratePrimesMap(this.flip, this.inverse = !this.inverse, this.rotate);
}
private void Rotate()
{
this.GeneratePrimesMap(this.flip, this.inverse, this.rotate = !this.rotate);
}
private void GenerateButton_Click(object sender, EventArgs e)
{
if (this.PrimesPictureBox.Image is Bitmap bitmap
&& bitmap.Clone() is Bitmap clone)
{
bitmap.Dispose();
this.PrimesPictureBox.Image = null;
this.PrimesPictureBox.Image = Fourier(clone);
clone.Dispose();
}
}
private void FormMain_Resize(object sender, EventArgs e)
{
this.GeneratePrimesMap(this.flip, this.inverse, this.rotate);
}
private void FormMain_Load(object sender, EventArgs e)
{
this.GeneratePrimesMap();
}
private void PrimesPictureBox_MouseMove(object sender, MouseEventArgs e)
{
if (this.primes != null && PrimesPictureBox.Image != null)
{
var x = e.X;
var y = e.Y;
if (x >= 0 && x < PrimesPictureBox.Image.Width
&& y >= 0 && y < PrimesPictureBox.Image.Height)
{
var cp = new PointF(PrimesPictureBox.Image.Width >> 1, PrimesPictureBox.Image.Height >> 1);
var dp = new PointF(x - cp.X, cp.Y - y);
var mp = new PointF(dp.X + (this.length >> 1) - 1, dp.Y + (this.length >> 1) - 1);
if (mp.X > this.length - 1)
mp.X = this.length - 1;
if (mp.Y > this.length - 1)
mp.Y = this.length - 1;
if (mp.X < 0)
mp.X = 0;
if (mp.Y < 0)
mp.Y = 0;
var p = this.primes![(int)mp.X, (int)mp.Y];
long n = p.Item2;
bool b = p.Item3;
var t = Math.Atan2(dp.Y, dp.X) / Math.PI * 180.0;
this.InfoLabel.Text = $"{(b ? 'P' : 'C')}:{n} ({dp.X},{dp.Y},{t:N2}°)";
}
}
}
private void ResetButton_Click(object sender, EventArgs e)
{
this.Reset();
}
private void FlipButton_Click(object sender, EventArgs e)
{
this.Flip();
}
private void InverseButton_Click(object sender, EventArgs e)
{
this.Inverse();
}
private void RotateButton_Click(object sender, EventArgs e)
{
this.Rotate();
}
}