9:42 AM
-10 on (?*) version of "find the largest square-free factor":

^(?=((?*(x+))(?=((x*)(?=\2\4*\$)x)(\3*\$))\5(?=\2*\$)|x*)*)\1

1 hour later…
10:52 AM
174 on consecutive-prime-constant-exponent:

# N = smallest root of N
^(?=(x+?)(((\1(x+))(?=(\4*)\1*\$)\4*(?=\5\$\6))*)x\$)\2

# Assert that there exists no trio of prime numbers such that N is divisible by the
# smallest and largest prime but not the middle prime.
(?!(((x+)(?=\9+\$)(x+))(?!\8+\$)(x+))\7*(?=\7\$)(?!(\11\10?)?((xx+)\14+|x?)\$))

# Assert that N is square-free (its prime factors all have single multiplicity)
((?=(xx+?)\16*\$)(?=(x+)(\17+\$))\18(?!\16*\$))*x\$

The overall algo is mine, but all I did was copy three of your regexes, change a + to a * in perfect powers, and adjust the back

2 hours later…
1:06 PM
Never mind, I got 155 by doing something significantly different (special-casing multiples of 12, can you believe that?)

2 hours later…
3:01 PM
137 and considerably faster, still room for improvement

3 hours later…
5:57 PM
I posted my totient regex: https://codegolf.stackexchange.com/questions/83533/calculate-eulers-totient-function/180255#180255

This time I polished the explanation a bit more, but feel free to improve it if you want to.

6:46 PM
@Grimy Just gave it a quick look and looks great... but you accidentally put the same TIO link for both versions. There's no TIO for the number-of-matches version.

Whoops
Fixed

@Grimy Did you realize that Martin Ender's solution does basically the exact same thing, and with the same length of regex?

Oh, I didnâ€™t
Guess that makes mine redundant, might as well remove it

Well, there is one interesting thing about it
That it works in ECMAScript 2018
(And the one from the Retina program also does)
And it is interesting that you independently came up with it, and that it's the same length
Something I'd like to look into is using Japt for some of the TIO links instead of (or in addition to) Node.js. I wonder if the number-of-matches solution could be well golfed using Japt.

1 hour later…
8:26 PM
Oops, I mean Leaky Nun's solution

8:40 PM
@Grimy `(x+x)` is more efficient in a lookbehind than `(xx+)`