regex for matching factorial numbers - multiplicity-comparing method, with molecular lookahead.txt

(?# Match factorial numbers in the domain ^x*$ )
^
(?=
	(?*(x(x*))(x*$))                        (?# \1 = conjectured for which \1! == tail; \2 = \1-1; \3 = tool to compare against \1 )
	(?!
		(x+)(?=\3)                          (?# \4 = any number <= \1 )
		(?!\4*$)                            (?# there is no \4 that doesn't divide tail )
	)
	(
		(?=
			(?=(x(x(x*?)))(\6+)$)           (?# \6 = smallest prime factor; \7 = \6-1; \8 = \7-1; \9 = tool to compare against \6 )
			(?=
				(                           (?# \10 = tool to make tail equal {largest factor that is not divisible by \6} later on )
					(                       (?# Divide tail by \6 as many times as possible )
						(?=
							(?=\6+$)
							(x(x*))         (?# Divide: \12 = tail / \6, with \13 = \12-1 )
							(?=\12*$)
							(?=\7+$)
							(\7\13+$)       (?# \14 = tool to make the tail equal \12 )
						)\14
					)*
				)
				x(x*)                       (?# \15 = {largest factor that is not divisible by \6} - 1 )
			)
			(x(x+))                         (?# \16 = tail / {\15+1} == largest prime power factor corresponding to \6; \17 = \16-1 )
			(?=\16*$)
			(?=\15+$)
			\15\17+$
		)
		(?=
			.*?(?!\1.)
			(                               (?# \18 = largest power of \6 less than or greater than \1 )
				(                           (?# Assert that tail is a power of \6 )
					(?=                     (?# Divide: \20 = tail / \6, with \21 = \20-1 )
						(x(x*))
						(?=\20*$)           (?# Testing for divisibility by \7 here isn't necessary, as tail is a power of \6 )
						(\7\21+$)           (?# \22 = tool to make the tail equal \20 )
					)\22
				)*x$
			)
		)
		(?=
			.*(?=\16\18$)                                    (?# Seed the loop )
			(
				(?# The first thing we need to do every iteration is decode the current number back into two prime powers,
					\24 and \28, where \24 is the smaller one, if they are different )
				(?=
					(x(x*?))                                (?# \24 = smaller prime power; \25 = \24-1 )
					(?!((x+)(?=\27+$)x+)\26*(?!\27+$)\26$)  (?# Assert that tail is a prime power)
					(\6+|x)$                                (?# \28 = larger prime power )
				)
				(?=
					.*?(?!\1.)                              (?# discard the remainder )
					(?=\24*$)                               (?# discard the remainder )
					(x(x*))                                 (?# \29 = floor{\1 / \24}; \30 = \29-1 )
					(?=\29*$)
					(?=\25+$)
					\25\30*$
				)
				(?# construct \6 ^ \29 by taking logarithm in base \6 and matching it against \29 )
				(?=
					.*
					(?=
						(                                   (?# Assert that tail is a power of \6 )
							(?=                             (?# Divide: \32 = tail / \6, with \33 = \32-1 )
								(x(x*))
								(?=\32*$)                   (?# Testing for divisibility by \7 here isn't necessary, as tail is a power of \6 )
								(\7\33+$)                   (?# \34 = tool to make the tail equal \32 )
							)\34
						)*x$
					)
					(?=x(x*))                               (?# tail will be \6 ^ \29; \35 = tail-1 )
					(?=(x*)\36(x?))                         (?# \36 = floor{tail / 2}, \37\36 = ceil{tail / 2}, \37 = tail % 2 )
					(?=
						(                                       (?# \38 = logarithm in base \6 of tail )
							x                                   (?# seed the loop )
							(?=
								(
									(?=
										(x*)\37(?=\36)          (?# tail = \36;  \40 = tool for decoding current state )
										\40                     (?# tail = current encoded state )
										(x*?)                   (?# \41 = iteration count )
										(?=
											(                   (?# Assert that tail is a power of \6 )
												(?=             (?# Divide: \43 = tail / \6, with \44 = \43-1 )
													(x(x*))
													(?=\43*$)   (?# Testing for divisibility by \7 here isn't necessary, as tail is a power of \6 )
													(\7\44+$)   (?# \45 = tool to make the tail equal \43 )
												)\45
											)*x$
										)
										(x(x*))                 (?# \46 = tail = A ^ {iteration count + 1}; \47 = \46-1 )
									)
									(?# encode state for next loop iteration, so that \41 will be incremented and \46 will be doubled )
									(?=
										(?# commence multiplication of \46 * \7; since we don't know which
											of \7 and \46 is larger/smaller, do two symmetric tests )
										.*
										(?=\46*$)
										(?=\7*$)
										(?=\46\8+$)
										(\7\47+$)               (?# \48 = \46 * \7 )
									)
									x\48                        (?# tail -= \46 * \7 + 1 )
								)+
							)
							x\41                                (?# Return logarithm in base A of B )
						|                                       (?# The main algorithm can't handle B<=A, so handle that below )
							x?\B                                (?# If B>1 return a value of 1, otherwise return a value of 0 )
						)
					)
					.*(?=\38$)\29$            (?# Assert that \38, the logarithm, equals \29 )
				)
				(?=
					.*(?=\28$)
					(x(x*))                   (?# \49 = \28 / {\35+1 == \6^\29}; \50 = \49-1 )
					(?=\49*$)                 (?# Testing for divisibility by \35 here isn't necessary, as dividend and divisor are both powers of \6 )
					\35\50*$
				)
				(?=
					.*(?=\24$)
					(x(x*))                   (?# \51 = \24 / \6; \52 = \51-1 )
					(?=\51*$)                 (?# Testing for divisibility by \7 here isn't necessary, as tail is a power of \6 )
					\7\52*$
				)
				.*(?=\49\51$)
			)*
			xx$
		)
		\10                                   (?# tail = {largest factor that is not divisible by \6} )
	)*
	(?!\1.|(xx+)\53+$)                        (?# Assert that the remaining factor is <= \1 and is prime )
)
\1