Find Twin Prime Pairs

let
  Source = Excel.CurrentWorkbook(){[Name = "Table1"]}[Content], 
  Prime = (x) =>
    List.Sum(
      List.Transform({1 .. Number.IntegerDivide(x, 2)}, each Number.From(Number.Mod(x, _) = 0))
    )
      = 1, 
  RESULT = Table.SelectRows(
    Source, 
    each Prime(_[#"Number 1 "])
      and Prime(_[#"Number 2"])
      and Number.Abs(_[#"Number 1 "] - _[#"Number 2"])
      = 2
  )
in
  RESULT

let
  Source = Excel.CurrentWorkbook(){[Name = "Table1"]}[Content], 
  Ans = Table.SelectRows(
    Source, 
    each 
      let
        a = Record.ToList(_), 
        b = {2}
          & List.Select(
            List.Numbers(3, Int64.From(Number.Sqrt(List.Max(a))) / 2, 2), 
            each _ < List.Min(a)
          )
      in
        if Number.Abs(a{0} - a{1}) = 2 then
          List.AllTrue(
            List.Transform(a, (a) => List.AllTrue(List.Transform(b, each Number.Mod(a, _) > 0)))
          )
        else
          false
  )
in
  Ans

let
  Source = Excel.CurrentWorkbook(){[Name = "Input"]}[Content], 
  IsPrime = (n) =>
    not List.Accumulate(
      {2 .. Number.RoundDown(Number.Sqrt(n))}, 
      false, 
      (s, d) => s or (Number.Mod(n, d) = 0)
    ), 
  Solution = Table.SelectRows(
    Source, 
    each IsPrime([#"Number 1 "])
      and IsPrime([Number 2])
      and Number.Abs([#"Number 1 "] - [Number 2])
      = 2
  )
in
  Solution

let
  Origen = Excel.CurrentWorkbook(){[Name = "Table1"]}[Content], 
  SelectRows = Table.SelectRows(Origen, each Number.Abs([Number 2] - [#"Number 1 "]) = 2), 
  Numero1 = List.Transform(
    SelectRows[#"Number 1 "], 
    (x) => List.Count(List.Select(List.Transform({1 .. x}, (y) => Number.Mod(x, y)), each _ = 0))
  ), 
  Numero2 = List.Transform(
    SelectRows[Number 2], 
    (x) => List.Count(List.Select(List.Transform({1 .. x}, (y) => Number.Mod(x, y)), each _ = 0))
  ), 
  Sol = Table.SelectRows(
    Table.FromColumns(
      {SelectRows[#"Number 1 "], SelectRows[Number 2], Numero1, Numero2}, 
      Table.ColumnNames(Origen) & {"Col3"} & {"Col4"}
    ), 
    each [Col3] = 2 and [Col4] = 2
  )[[#"Number 1 "], [Number 2]]
in
  Sol

let
  Fonte = Tabela1, 
  fil = Table.SelectRows(
    Fonte, 
    each ([#"Number 1 "] - [Number 2] = 2) or ([#"Number 1 "] - [Number 2] = - 2)
  ), 
  add = Table.AddColumn(
    fil, 
    "primo", 
    each [
      a = Number.From([#"Number 1 "]), 
      b = List.Count(
        List.Select(
          List.Transform(List.Buffer({1 .. a}), (x) => a / x - Number.RoundDown(a / x)), 
          each _ = 0
        )
      ), 
      a1 = Number.From([Number 2]), 
      b1 = List.Count(
        List.Select(
          List.Transform(List.Buffer({1 .. a1}), (x) => a1 / x - Number.RoundDown(a1 / x)), 
          each _ = 0
        )
      ), 
      c = b = b1
    ][c]
  ), 
  res = Table.SelectRows(add, each ([primo] = true))[[#"Number 1 "], [Number 2]]
in
  res

let
  Source = RawData, 
  FiltAbsDiff2 = Table.SelectRows(
    Table.AddColumn(Source, "AbsDiff", each Number.Abs([#"Number1 "] - [Number2]), Int64.Type), 
    each [AbsDiff] = 2
  ), 
  RunRscript = R.Execute(
    "library(primes)#(lf)df <- dataset#(lf)df$isprime1 <- is_prime(df$Number1)#(lf)df$isprime2 <- is_prime(df$Number2)#(lf)df", 
    [dataset = FiltAbsDiff2]
  ), 
  RResults = RunRscript{[Name = "df"]}[Value], 
  FilterNonPrimes = Table.SelectRows(RResults, each ([isprime2] = true)), 
  RemoveOther = Table.SelectColumns(FilterNonPrimes, {"Number1", "Number2"})
in
  RemoveOther

=FILTER(A2:B10,BYROW(A2:B10,LAMBDA(a,AND(MOD(a,SEQUENCE((MAX(a)^0.5)/2,,3,2)),ABS(SUM(a*{-1,1}))=2))))

=FILTER(A2:B10,MAP(A2:A10,B2:B10,LAMBDA(a,b,LET(p,LAMBDA(x,SUM(N(MOD(x,SEQUENCE(x^0.5))=0))),ABS(b-a)=p(b)+p(a)))))

=FILTER(A2:B10,BYROW(MAP(A2:B10,LAMBDA(a,LET(r,a/SEQUENCE(SQRT(a)),SUM(--(INT(r)=r))=1))),LAMBDA(a,SUM(-a)))+ABS(A2:A10-B2:B10)=0)

=LET(N,A2:B10,FILTER(N,(ABS(TAKE(N,,1)-TAKE(N,,-1))=2)*BYROW(MAP(N,LAMBDA(A,E_ISPrimeNumber(A))),LAMBDA(A,SUM(--A)))=2))

E_ISPrimeNumber:
=LAMBDA(Number,LET(c,{2357},D,Number/TOCOL(VSTACK(c,SEQUENCE(Number^0.5/6,,2)*6+{-11}),3),OR(Number=c,AND(D-INT(D),Number>1))))

=FILTER(A2:B10, MAP(A2:A10,B2:B10, LAMBDA(v,w, LET(D, LAMBDA(n, IF(n<5,2,VSTACK(2,SEQUENCE(ROUNDDOWN(((n^0.5)-3),0)/2+1,,3,2)))),
P, LAMBDA(x, LET(A, D(x), SWITCH(x,1,0,2,1,--(SUM(MAP(A, LAMBDA(a, --(MOD(x,a)=0) )))=0) ) )), P(v)*P(w)*(ABS(w-v)=2))) ))

=LET(
 _e1, LAMBDA(x, y, ABS(x - y) = 2),
 _e2, LAMBDA(v, OR(MOD(v, SEQUENCE(ROUNDUP(SQRT(v), 0) - 1, , 2)) = 0)),
 FILTER(
 A2:B10,
 MAP(
 A2:A10,
 B2:B10,
 LAMBDA(a, b,
 LET(
 _cond1, _e1(a, b),
 _cond2, NOT(OR(_e2(a), _e2(b))),
 AND(_cond1, _cond2)
 )
 )
 )
 )
)

=LET(
 _list, FILTER(A2:B10, BYROW(A2:B10, LAMBDA(a, ABS(INDEX(a, , 2) - INDEX(a, , 1)) = 2))),
 _num1, DROP(_list, , -1),
 _num2, DROP(_list, , 1),
 FILTER(
 _list,
 MAP(
 _num1,
 _num2,
 SQRT(_num1),
 SQRT(_num2),
 LAMBDA(a, b, c, d,
 LET(
 _r1, OR(MOD(a, SEQUENCE(c - 1, , 2)) = 0),
 _r2, OR(MOD(b, SEQUENCE(d - 1, , 2)) = 0),
 NOT(OR(_r1, _r2))
 )
 )
 )
 )
)

=LET(u,A2:B10,v,A1:B1,
p,MAP(u,LAMBDA(x,LET(sq,SEQUENCE(SQRT(x)),a,x/sq,SUM(ABS(ABS(INT(a)=a)=1))))),
q,FILTER(u,BYROW(p,SUM)=2),
s,ABS(BYROW(q*{-1,1},SUM)),
w,FILTER(q,s=2),
VSTACK(v,w))

=FILTER(A2:B10,MAP(A2:A10,B2:B10,LAMBDA(a,b,AND(ISPRIME(a),ISPRIME(b),ABS(a-b)=2))))

Where ISPRIME() is a named function:

=LAMBDA(x,SUM(N(MOD(x/SEQUENCE(SQRT(x)),1)=0))=1)

=LET(A, A2:B10,
B, MAP(TAKE(A,,1), TAKE(A,,-1), LAMBDA(Q,R,
LET(
B, Q,
C, R,
D, ABS(C-B)=2,
E, MIN(MOD(B,SEQUENCE(ROUNDUP(SQRT(B),0)-1,,2)))>0,
F, MIN(MOD(C,SEQUENCE(ROUNDUP(SQRT(C),0)-1,,2)))>0,
G, D*E*F, G))),
FILTER(A, B))

=AND(ISNUMBER(A2), ISNUMBER(B2), ISPRIME(A2), ISPRIME(B2), ABS(A2-B2) =2)

from sympy import isprime
twin_primes = (
 xl("A1:B10", headers=True)
 .query("abs(`Number 1` - `Number 2`) == 2")
 .loc[lambda d: d["Number 1"].map(isprime) & d["Number 2"].map(isprime)]
 .reset_index(drop=True))