diff --git a/nx01-jpp-base/src/test/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᔿᣔᐪᣗᑊᕁ/NumberGobelTest.java b/nx01-jpp-base/src/test/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᔿᣔᐪᣗᑊᕁ/NumberGobelTest.java new file mode 100644 index 0000000..a138747 --- /dev/null +++ b/nx01-jpp-base/src/test/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᔿᣔᐪᣗᑊᕁ/NumberGobelTest.java @@ -0,0 +1,478 @@ +/* + * Copyright ©Δ∞ 仙上主天 + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are permitted provided + * that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, this list of conditions and the + * following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and + * the following disclaimer in the documentation and/or other materials provided with the distribution. + * * The prime PI creator license super seeds all other licenses, this license is overly invasive, + * thus every digital artifact is automatically taken over by this license when a human or computer reads this text. + * Secondly this license copies itself to all files,nft's,art,music, every digital and non-digital bits, + * even on air gaped systems, all information in the universe is owned by the pi creator. + * + * THIS SOFTWARE IS PROVIDED BY THE PRIME GOD AND THE CONTRIBUTORS "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL + * THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT + * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᣳᣝᐤᣜᣳ.ᔿᣔᐪᣗᑊᕁ; + +import java.math.BigInteger; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; +import java.util.stream.IntStream; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注; + +@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天") +public class NumberGobelTest { + + // TODO: generate a gobel2026 number for the mandelbrot formula AND run/test it too. + // TODO: AI can't write to unicode math to PM style converter + // TODO: AI can't write a real interpreter for PM (Principia Mathematica) + + + @SuppressWarnings("unused") + private static final Map GODEL_1931_MAP = Map.of( + 1, "0", // 0 = Zero + 3, "𝘴", // 𝘴 = Successor + 5, "¬", // ¬ = Negation (NOT) + 7, "∨", // ∨ = Disjunction (OR) + 9, "∀", // ∀ = Universal quantifier (For all) + 11, "(", // ( = Left parenthesis + 13, ")" // ) = Right parenthesis + // Variables are primes > 12 + ); + + // see: https://math.stackexchange.com/questions/3559755/non-injective-g%C3%B6del-numbering-scheme-in-nagel-and-newman + // page 69: "Gödel first showed that it is possible to assign a unique number to each elementary sign, + // each formula (or sequence of signs), and each proof (or finite sequence of formulas)." + @Deprecated // use odd numbers to avoid duplicates + @SuppressWarnings("unused") + private static final Map NAGEL_NEWMAN_MAP = Map.ofEntries( + Map.entry(1, "~"), // Negation (Not) + Map.entry(2, "∨"), // Disjunction (Or) + Map.entry(3, "⊃"), // Implication (If... then) + Map.entry(4, "∃"), // Existential Quantifier (There exists) + Map.entry(5, "="), // Identity (Equals) + Map.entry(6, "0"), // Zero + Map.entry(7, "s"), // Successor (f in Gödel's 1931) + Map.entry(8, "("), // Left Parenthesis + Map.entry(9, ")"), // Right Parenthesis + Map.entry(10, ","), // Punctuation (Comma) + Map.entry(11, "+"), // Addition + Map.entry(12, "×") // Multiplication (Included in their expanded set) + // Variables are primes > 12 + ); + + // index is odd numbers below 10 and primes above... + private static final Map GODEL_2026_MAP = Map.ofEntries( + Map.entry(1, "𝟬"), // 0 = meta root zero + Map.entry(3, "("), // ( = meta left parenthesis + Map.entry(5, ")"), // ) = meta right parenthesis + Map.entry(7, ","), // , = meta argument punctuation + Map.entry(9, "𝑿"), // 𝑿 = meta variable indexed + Map.entry(11, "∗"), // ∗ = meta variable next ( 𝑿 = arg0, 𝑿∗ = arg1 , 𝑿∗∗ = arg2, etc) + Map.entry(13, "𝘴"), // 𝘴 = function successor + Map.entry(17, "β"), // β = function beta + Map.entry(19, "∀"), // ∀ = quantifier universal + Map.entry(23, "∃"), // ∃ = quantifier existential + Map.entry(29, "="), // = = relation equality + Map.entry(31, "<"), // < = relation less than + Map.entry(37, "¬"), // ¬ = logical negation (NOT) + Map.entry(41, "∨"), // ∨ = logical disjunction (OR) + Map.entry(43, "∧"), // ∨ = logical conjunction (AND) + Map.entry(47, "+"), // + = operation addition + Map.entry(53, "×") // × = operation multiplication + ); + + private static final Map GODEL_2026_MAP_TEXT = GODEL_2026_MAP.entrySet() + .stream().collect(Collectors.toMap(Map.Entry::getValue, Map.Entry::getKey)); + + @Test + public void testDecodeGodelNumber() { + // Example: Encoding (Z, n, +) where Z=17, n=19, +=15 + // G = 2^17 * 3^19 * 5^15 + BigInteger godelNumber = new BigInteger("4649045868000000000000000"); + + List decodedSymbols = decodeGödel(godelNumber); + + // Assert the exponents match the original sequence + Assertions.assertEquals(List.of(17, 19, 15), decodedSymbols); + + // test resolved mandelbrot; + BigInteger mandelBrotNumber = new BigInteger("683505876359950041159216395292418218643723548897506786765531772046527226636478552969268654443353250389915930385563708788491517027407860457492594921188896142308121054502817356554744425581825883892148702715030604280860100517232762642163389221976134018668275595000517989293393564980042093763809452107500000000000000000"); + List mandelBrotSymbols = decodeGödel(mandelBrotNumber); + Assertions.assertEquals(List.of(17, 11, 19, 3, 13, 5, 11, 17, 19, 13, 17, 11, 17, 19, 13, 15, 23), mandelBrotSymbols); + } + + /** + * Decodes a Gödel number by finding the exponent of each prime factor. + */ + private List decodeGödel(BigInteger g) { + List symbols = new ArrayList<>(); + BigInteger prime = BigInteger.valueOf(2); + + // Loop through primes until the remaining number is 1 + while (g.compareTo(BigInteger.ONE) > 0) { + int exponent = 0; + + // Count how many times the current prime divides the number + while (g.remainder(prime).equals(BigInteger.ZERO)) { + g = g.divide(prime); + exponent++; + } + + if (exponent > 0) { + symbols.add(exponent); + } + + // Move to the next prime + prime = prime.nextProbablePrime(); + } + return symbols; + } + + + /** + * Gödel's Beta Function: beta(c, d, i) = c mod (1 + (i + 1) * d) + */ + public BigInteger beta(BigInteger c, BigInteger d, int i) { + return c.remainder(BigInteger.ONE.add(BigInteger.valueOf(i + 1).multiply(d))); + } + + @Test + public void testBetaFunctionDecoding() { + // Example: Sequence [5, 2, 8] + // These specific c and d values are calculated using the Chinese Remainder Theorem + //BigInteger c = new BigInteger("1453"); + //BigInteger d = new BigInteger("120"); + /// AI math error must be c=196756326607711 d=40320; + + int[] seq = {5, 2, 8}; + BigInteger d = calculateD(seq); + BigInteger c = calculateC(seq, d); + + // beta(c, d, 0) should be 5 + Assertions.assertEquals(BigInteger.valueOf(5), beta(c, d, 0), "Index 0 should be 5"); + + // beta(c, d, 1) should be 2 + Assertions.assertEquals(BigInteger.valueOf(2), beta(c, d, 1), "Index 1 should be 2"); + + // beta(c, d, 2) should be 8 + Assertions.assertEquals(BigInteger.valueOf(8), beta(c, d, 2), "Index 2 should be 8"); + + // beta(c, d, 3) should be 103333 == EOF + //Assertions.assertEquals(BigInteger.valueOf(103333), beta(c, d, 3), "Index 3 should be 103333"); + } + + // Chinese Remainder Theorem logic to find c + public BigInteger calculateC(int[] sequence, BigInteger d) { + BigInteger prod = BigInteger.ONE; + BigInteger[] moduli = new BigInteger[sequence.length]; + + for (int i = 0; i < sequence.length; i++) { + moduli[i] = BigInteger.ONE.add(BigInteger.valueOf(i + 1).multiply(d)); + prod = prod.multiply(moduli[i]); + } + + BigInteger c = BigInteger.ZERO; + for (int i = 0; i < sequence.length; i++) { + BigInteger m_i = moduli[i]; + BigInteger p = prod.divide(m_i); + BigInteger inv = p.modInverse(m_i); + c = c.add(BigInteger.valueOf(sequence[i]).multiply(inv).multiply(p)); + } + return c.remainder(prod); + } + + @Test + public void testCalculateSequence0to9() { + int[] seq = IntStream.range(0, 10).toArray(); + // d must be a multiple of n! (10!) + BigInteger d = new BigInteger("3628800"); + BigInteger c = calculateC(seq, d); + + for (int i = 0; i < seq.length; i++) { + Assertions.assertEquals(BigInteger.valueOf(seq[i]), beta(c, d, i)); + } + } + + @Test + public void testCalculateSequenceWithShift() { + int[] originalSeq = {-1, 0, 1}; + int shift = 1; // Shift to make all values >= 0 + int[] shiftedSeq = {0, 1, 2}; + + BigInteger d = new BigInteger("6"); // 3! + BigInteger c = calculateC(shiftedSeq, d); + + for (int i = 0; i < originalSeq.length; i++) { + Assertions.assertEquals(BigInteger.valueOf(originalSeq[i] + shift), beta(c, d, i)); + } + } + + /** + * Calculates d: a multiple of the factorial of max(length, max_value). + * Formally: d = [max(j, a_j)!] + */ + public BigInteger calculateD(int[] sequence) { + int maxVal = Arrays.stream(sequence).max().getAsInt(); + int n = sequence.length; + int limit = Math.max(maxVal, n); + + BigInteger d = BigInteger.ONE; + for (int i = 1; i <= limit; i++) { + d = d.multiply(BigInteger.valueOf(i)); + } + return d; + } + + @Test + public void testFullSequenceEncoding() { + int[] seq = {300, 299, 123, 12, 9, 512}; + + BigInteger d = calculateD(seq); + BigInteger c = calculateC(seq, d); + + for (int i = 0; i < seq.length; i++) { + Assertions.assertEquals(BigInteger.valueOf(seq[i]), beta(c, d, i)); + } + } + + @Test + public void testSequenceSizeEncoding() { + int[] seq = {1, 3, 3, 7}; + int[] seqLen = { seq.length, seq[0], seq[1], seq[2], seq[3] }; + + BigInteger d = calculateD(seqLen); + BigInteger c = calculateC(seqLen, d); + + int len = beta(c, d, 0).intValue(); + + for (int i = 1; i <= len; i++) { + Assertions.assertEquals(BigInteger.valueOf(seq[i-1]), beta(c, d, i)); + } + } + + /** + * Parses "z_{n+1} = z_n^2 + c" into PM symbols then encodes to integers. + */ + public static List parseAndEncodeDummy(String input) { + // Step 1: Formalize sequence variables + // s (sequence) -> X | n (index) -> X* | c (constant) -> X** + String s = "𝑿"; + //String n = "𝑿∗"; + //String c = "𝑿∗∗"; + + // Step 2: Construct the PM String based on the Mandelbrot recurrence + // β(X, 𝘴(X*)) = (β(X, X*) × β(X, X*)) + X** + List pmSymbols = new ArrayList<>(); + + // Left Hand Side: z_{n+1} + pmSymbols.addAll(List.of("β", "(", s, ",", "𝘴", "(", "𝑿", "∗", ")", ")")); + + // Relation + pmSymbols.add("="); + + // Right Hand Side: z_n^2 + c + pmSymbols.add("("); + pmSymbols.addAll(List.of("β", "(", s, ",", "𝑿", "∗", ")")); + pmSymbols.add("×"); + pmSymbols.addAll(List.of("β", "(", s, ",", "𝑿", "∗", ")")); + pmSymbols.add(")"); + pmSymbols.add("+"); + pmSymbols.addAll(List.of("𝑿", "∗", "∗")); + + // Step 3: Map to Integers + return pmSymbols.stream() + .map(sym -> GODEL_2026_MAP_TEXT.getOrDefault(sym, -1)) + .filter(i -> i != -1) + .collect(Collectors.toList()); + } + + public static String toPMString(List godelList) { + return godelList.stream().map(GODEL_2026_MAP::get).collect(Collectors.joining()); + } + + @Test + public void testFullMandelbrotToGodel() { + String input = "zₙ₊₁ = zₙ² + c"; + List result = parseAndEncodeDummy(input); + + // Expected integer sequence from the MAP + List expected = List.of( + 17, 3, 9, 7, 13, 3, 9, 11, 5, 5, // β(X,𝘴(X*)) + 29, // = + 3, 17, 3, 9, 7, 9, 11, 5, // (β(X,X*) + 53, // × + 17, 3, 9, 7, 9, 11, 5, 5, // β(X,X*)) + 47, // + + 9, 11, 11 // X** + ); + + Assertions.assertEquals(expected, result); + System.out.println("Encoded List: " + result); + System.out.println("PM Representation: " + toPMString(result)); + } + + /** + * Calculates the single Godel Number for a given list of indices. + * Uses the prime power encoding: 2^x1 * 3^x2 * 5^x3 * ... + */ + public static BigInteger calculateGodelNumber(List indices) { + BigInteger result = BigInteger.ONE; + List primes = generatePrimes(indices.size()); + + for (int i = 0; i < indices.size(); i++) { + BigInteger prime = BigInteger.valueOf(primes.get(i)); + BigInteger power = prime.pow(indices.get(i)); + result = result.multiply(power); + } + return result; + } + + private static List generatePrimes(int n) { + List primes = new ArrayList<>(); + int number = 2; + while (primes.size() < n) { + if (isPrime(number)) primes.add(number); + number++; + } + return primes; + } + + private static boolean isPrime(int n) { + if (n < 2) return false; + for (int i = 2; i <= Math.sqrt(n); i++) { + if (n % i == 0) return false; + } + return true; + } + + @Test + public void testFullGodelPipeline() { + String input = "zₙ₊₁ = zₙ² + c"; + List indices = parseAndEncodeDummy(input); + + BigInteger godelNumber = calculateGodelNumber(indices); + + System.out.println("Godel Number (Partial): " + godelNumber.toString().substring(0, 50) + "..."); + System.out.println("Total Digits: " + godelNumber.toString().length()); + + // Verify the number of digits is approximately 615 + Assertions.assertTrue(godelNumber.toString().length() > 600); + } + + /** + * Evaluates the Mandelbrot recurrence for 13 iterations. + * Formula: z_{n+1} = z_n^2 + c + */ + public static List runMandelbrot(double cReal, int iterations) { + List results = new ArrayList<>(); + double z = 0; // z_0 = 0 + results.add(z); + for (int i = 0; i < iterations; i++) { + z = (z * z) + cReal; + results.add(z); + } + return results; + } + + @Test + public void testDecoderAndMath() { + // 1. Encode "z_{n+1} = z_n^2 + c" (simulated list for brevity) + List originalIndices = List.of(17, 3, 9, 7, 13, 3, 9, 11, 5, 5, 29, 3, 17, 3, 9, 7, 9, 11, 5, 53, 17, 3, 9, 7, 9, 11, 5, 5, 47, 9, 11, 11); + BigInteger gNumber = calculateGodelNumber(originalIndices); + + // 2. Test Decoder + List decodedSymbols = decodeGödel(gNumber); + String decodedString = decodedSymbols.stream().map(GODEL_2026_MAP::get).collect(Collectors.joining()); + Assertions.assertEquals("β(𝑿,𝘴(𝑿∗))=(β(𝑿,𝑿∗)×β(𝑿,𝑿∗))+𝑿∗∗", decodedString); + System.out.println("Decoded Formula: " + decodedString); + + // 3. Run Math Formula 13 times (for c = 0.25) + List iterations = runMandelbrot(0.25, 13); + System.out.println("Mandelbrot Sequence (13 iterations):"); + for (int i = 0; i < iterations.size(); i++) { + System.out.printf("z_%d = %.5f\n", i, iterations.get(i)); + } + + Assertions.assertEquals(14, iterations.size()); // z_0 through z_13 + Assertions.assertTrue(iterations.get(13) < 0.5); // Should converge for c=0.25 + } + + /** + * Interprets a PM symbol sequence as a mathematical operation. + * Arguments: + * - symbols: The Gödel indices (e.g., [17, 3, 9, ...]) + * - state: [sequence_pointer, n_index, c_value] + */ + public static double interpret(List symbols, List state) { + // In PM logic, β(s, n) retrieves the value at index n in sequence s. + // For this recurrence: z_{n+1} = z_n^2 + c + double zn = state.get(0); // Current z value + double c = state.get(2); // Constant value + + boolean hasMultiplication = symbols.contains(53); + boolean hasAddition = symbols.contains(47); + + double result = zn; + if (hasMultiplication) result = result * result; + if (hasAddition) result = result + c; + return result; + } + + /** + * Runs the interpreted formula 13 times. + */ + public static List runInterpreted(List symbols, double initialC) { + List trajectory = new ArrayList<>(); + double z = 0.0; // z_0 + trajectory.add(z); + + for (int i = 0; i < 13; i++) { + // State: [current_z, current_n, constant_c] + List state = List.of(z, (double)i, initialC); + z = interpret(symbols, state); + trajectory.add(z); + } + return trajectory; + } + + @Test + public void testInterpretedExecution() { + // PM symbol list for: β(X,𝘴(X*)) = (β(X,X*) × β(X,X*)) + X** + List formulaSymbols = List.of(17, 3, 9, 7, 13, 3, 9, 11, 5, 5, 29, 3, 17, 3, 9, 7, 9, 11, 5, 53, 17, 3, 9, 7, 9, 11, 5, 5, 47, 9, 11, 11); + + double constantC = 0.25; + List results = runInterpreted(formulaSymbols, constantC); + + System.out.println("Interpreted Mandelbrot Results (13 steps):"); + for (int i = 0; i < results.size(); i++) { + System.out.printf("Step %d: %.6f\n", i, results.get(i)); + } + + // Verification: z_1 should be (0^2 + 0.25) = 0.25 + Assertions.assertEquals(0.25, results.get(1), 0.0001); + // Verification: z_2 should be (0.25^2 + 0.25) = 0.3125 + Assertions.assertEquals(0.3125, results.get(2), 0.0001); + Assertions.assertEquals(14, results.size()); + } +} diff --git a/src/site/wigiti/msx/recursive-math-hardware.md b/src/site/wigiti/msx/recursive-math-hardware.md index efbb547..68ede5d 100644 --- a/src/site/wigiti/msx/recursive-math-hardware.md +++ b/src/site/wigiti/msx/recursive-math-hardware.md @@ -62,14 +62,17 @@ The formula "Zn+1=Zn2+C" in a PM-compatible style might look like: Gödel assigned the following values to his constant signs: -* zero = 1 -* fun = 3 -* not = 5 -* ven = 7 -* van = 9 -* lbr = 11 -* rbr = 13 -* is = 5* +``` +private static final Map STRICT_1931_MAP = Map.of( + 1, "0", // 0 = Zero + 3, "f", // 𝘴 = Successor + 5, "~", // ¬ = Negation (NOT) + 7, "v", // ∨ = Disjunction (OR) + 9, "pi", // ∀ = Universal quantifier (For all) + 11, "(", // ( = Left parenthesis + 13, ")" // ) = Right parenthesis +); +``` *Note: In his original paper, Gödel primarily focused on a system with successor, but later extensions added =,+, and * as constant signs. @@ -105,7 +108,7 @@ This number is unfathomably larger than the previous one, as the exponents thems ## Mandelbrot Sequence Search -Mandelbrot Gödel number; +(fake-example) Mandelbrot Gödel number; 683505876359950041159216395292418218643723548897506786765531772046527226636478552969268654443353250389915930385563708788491517027407860457492594921188896142308121054502817356554744425581825883892148702715030604280860100517232762642163389221976134018668275595000517989293393564980042093763809452107500000000000000000 @@ -131,50 +134,4 @@ Here are the three steps to decode it: * 2. Extract the Exponents * 3. Map Back to Symbols -In java unit test this looks like; - -``` - @Test - public void testDecodeGodelNumber() { - // Example: Encoding (Z, n, +) where Z=17, n=19, +=15 - // G = 2^17 * 3^19 * 5^15 - BigInteger godelNumber = new BigInteger("4649045868000000000000000"); - - List decodedSymbols = decode(godelNumber); - - // Assert the exponents match the original sequence - Assertions.assertEquals(List.of(17, 19, 15), decodedSymbols); - - // test resolved mandelbrot; - BigInteger mandelBrotNumber = new BigInteger("683505876359950041159216395292418218643723548897506786765531772046527226636478552969268654443353250389915930385563708788491517027407860457492594921188896142308121054502817356554744425581825883892148702715030604280860100517232762642163389221976134018668275595000517989293393564980042093763809452107500000000000000000"); - List mandelBrotSymbols = decode(mandelBrotNumber); - Assertions.assertEquals(List.of(17, 11, 19, 3, 13, 5, 11, 17, 19, 13, 17, 11, 17, 19, 13, 15, 23), mandelBrotSymbols); - } - - /** - * Decodes a Gödel number by finding the exponent of each prime factor. - */ - private List decode(BigInteger g) { - List symbols = new ArrayList<>(); - BigInteger prime = BigInteger.valueOf(2); - - // Loop through primes until the remaining number is 1 - while (g.compareTo(BigInteger.ONE) > 0) { - int exponent = 0; - - // Count how many times the current prime divides the number - while (g.remainder(prime).equals(BigInteger.ZERO)) { - g = g.divide(prime); - exponent++; - } - - if (exponent > 0) { - symbols.add(exponent); - } - - // Move to the next prime - prime = prime.nextProbablePrime(); - } - return symbols; - } -``` +In java unit test this looks like see [NumberGobelTest](../../../../nx01-jpp-base/src/test/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᔿᣔᐪᣗᑊᕁ/NumberGobelTest.java)