Liczby pierwsze

Question

czy można publikować publicznie odkrycie dotyczące rozmieszczenia liczb pierwszych czy nie ze względów bezpieczeństwa ? (zgłosić to "gdzieś" do osób zajmujących się tym tematem)

Comments

Idz na pierwszy lepszy Uniwesytet by ktoś to zweryfikował. Później okaże się czy to ma racje bytu.

---

ciężko się przebić z politechniki łódzkiej dostałem namiar na osobę zajmującą się zagadnieniem to mi nie odpisała, pisałem na FB do uniwersytetu Jagiellońskiego też bez odzewu i do astrofazy (kanał na YT) o pomoc w kontakcie bo zrobili nagranie o liczbach pierwszych z dr. Millerem również bez odzewu. jak dla mnie w tym na co wpadłem jest coś wartego uwagi bo wskazuje przyszłe liczby pierwsze ale nie ma kto tego zweryfikować czy się nie mylę, na forum wynalazca do którego należę proponowano mi abym to opublikował ale nie wiem czy można bo to sprawy bezpieczeństwa. mam znajomego na FB który zadeklarował się że rzuci okiem (zawsze coś - opinia z boku)

---

Najszybciej byłoby gdybyś podszedł. Trudniej jest zignorować kogoś fizycznie. Co do publikacji, to nie wiem, tutaj możemy gdybać. Ewentualnie poszukać świeżo upieczonych doktorantów - szybciej znajdą czas niż profesorowie.

---

@Dambru, trochę to twierdzenie się wyklucza, dlatego pewnie nikt na to nie marnuje swojego czasu, z jednej strony przykre z drugiej bezpieczne. Liczby pierwsze "są nieprzewidywalne" więc teoria, że " bo wskazuje przyszłe liczby pierwsze" jest nieprawdziwa, nawet nie miałoby to szansy na dowód, bo Sito Eratostenesa potrafi nam wyznaczyć nieskończenie wiele liczb pierwszych kolejnych ...  do n, a n może być zawsze n+1 :) ograniczone. 

---

są nieprzewidywalne bo jeszcze nikt tego nie obalił choć spirala Ulama już pokazuje że to nie jest chaos a ukazuje pewien "wzór" ja twierdzę że jest coś na rzeczy bo wskazuje mi liczby pierwsze (zawsze jeszcze się nie "pomyliło") do liczby około 130 (dalej nie robiłem) ale musiał by to obejrzeć jakiś fachowiec, żeby to zweryfikować czy moje założenia są słuszne. jak ludzie by pisali że można to upubliczniać to w 5 min bym to pokazał

---

@Dambru, przejrzyj forum, w zeszłym roku był tu już user z nową teorią liczb pierwszych, może on ci pomoże.

---

dzięki za info

Answer 1

Jedynie po konsultacji z CosmoWielki :)

Comments

("#### Prime Test Mart'a z filtrem GCD i eksperymentem y = (a-1)^d mod L ####")

import random
import sys
import math

# Zwiększenie limitu długości liczby w postaci tekstu (np. dla 50000 cyfr)
sys.set_int_max_str_digits(5_000_000)

def miller_rabin_test(L, k=1):
    """Nieklasyczny test pierwszości Miller-Rabin z dodatkowymi eksperymentami"""
    if L < 2:
        return False
    if L in (2, 3):
        return True
    if L % 2 == 0:
        return False

    # Rozkład: L - 1 = (2^r) * d
    r, d = 0, L - 1
    while d % 2 == 0:
        r += 1
        d //= 2

    for _ in range(k):
        a = random.randint(2, L - 2)

        # Szybki filtr: jeśli a i L mają wspólny dzielnik > 1, to L złożona
        if math.gcd(a, L) != 1:
            return False

        # Klasyczny test MR
        x = pow(a, d, L)

        # Eksperyment: y = (a - 1)^d mod L — dziwny test, zostawiamy do zabawy
        y = pow(a - 1, d, L)

        # Jeśli x lub y są równoważne -1 mod L, kontynuujemy
        if x in (1, L - 1) or y in (1, L - 1):
            continue

        # Iteracyjne potęgowanie: sprawdzamy, czy x podniesiony do 2^j mod L daje -1
        for _ in range(r - 1):
            x = pow(x, 2, L)
            if x == L - 1:
                break
        else:
            return False  # Złożona – znaleziono świadka

    return True  # Prawdopodobnie pierwsza

# ----------------- INTERFEJS ------------------

print("######## Prime Test Mart'a z filtrem GCD i eksperymentem y = (a-1)^d mod L #########")
try:
    L = int(input(" Podaj liczbę początkową do sprawdzenia: "))
    N = int(input(" Podaj ilość kolejnych liczb do sprawdzenia: "))
except ValueError:
    print("⛔ Błąd: Podano niepoprawną wartość.")
    exit()

for i in range(N):
    liczba = L + i
    wynik = miller_rabin_test(liczba)

    if wynik:
        print(f"\n{liczba} ✅ Prawdopodobnie pierwsza")
    else:
        print(f"\n{liczba} ❌ Złożona")

Przyspieszyć wykrywanie Liczb pierwszych bardzo trudno, tym bardziej jak się nie zna dlaczego są one pierwszymi? 

 

https://drive.google.com/drive/folders/172zNTFxzoJ0nFpVp5uEWOMpkMcSM60Y0?usp=sharing

https://youtu.be/D9FH2Sn4evQ?si=H3brHTHiFwltPNCq

---

POZORNY CHAOS LICZB PIERWSZYCH I ZŁOŻONYCH

N = 37  # rozmiar kwadratu
print("MART- SZABLON LICZB NATURALNYCH/PIERWSZYCH")

# Kody kolorów ANSI
RED = "\033[91m"
GREEN = "\033[92m"
RESET = "\033[0m"

# sprawdzanie pierwszości
def is_prime(num):
    if num < 2:
        return False
    for i in range(2, int(num**0.5) + 1):
        if num % i == 0:
            return False
    return True

for row in range(1, N+1):
    line = ""
    count = 0
    while count < N:
        group_size = min(row, N - count)  # ile jedynek w tej grupie
        group_parts = []

        for offset in range(group_size):
            col = count + offset + 1  # numer kolumny (1..N)

            # jeśli kolumna jest pierwsza i wiersz mieści się w "zasięgu" tej liczby
            if is_prime(col) and row <= col:
                group_parts.append(RED + "1" + RESET)
            else:
                group_parts.append(GREEN + "1" + RESET)

        if group_size == row:  # zamknięty
            group = "(" + "  ".join(group_parts) + ")"
        else:  # otwarty
            group = "(" + "  ".join(group_parts)
        line += group
        count += group_size
    print(line)

Answer 2

Sprawdzałeś tylko do liczby 130? Dalej nie? Przecież zwykłe sito Erastotensa wygeneruje Ci więcej liczb w sensownym czasie. Ale nawet nie musisz tego robić, tutaj masz listę 1000 pierwszych liczb pierwszych. Największa znana liczba pierwsza składa się z 41 mln cyfr (źródło).

Na moje oko, to po prostu Twoje rozwiązanie nie jest wiarygodne, dlatego nikt Ci nie odpowiada. Sprawdź, czy algorytm działa dla pierwszego miliona liczb pierwszych, jak tak, to można zgłębiać temat dalej. I nie jesteś jedyny, który zajmował się szukaniem wzorców, ja też się tym bawiłem.

Upublicznić możesz choćby na arXiv, ale bez głębszego researchu jest ryzyko, że się ośmieszysz.

Comments

to nie jest program tylko "wykres" nie chciało mi się ręcznie dalej robić. wysłałem to na mesanger około 1 roku temu do pewnej osoby zajmującą się liczbami pierwszymi to nic nie odpisała ani tak ani nie, biorę pod uwagę to że się ośmieszę ale jak dla mnie są przesłanki aby to przedstawić "publicznie".

---

A nie jesteś w stanie tego wykresu narysować dla większych liczb? Można to zautomatyzować prostym skryptem w Pythonie.

To, co może Cię powstrzymywać przed publikacją, to export control. Czyli jeśli Twoje rozwiązanie mogłoby mieć podwójne zastosowanie, to przesyłanie takiego algorytmu może naruszać przepisy dotyczące bezpieczeństwa. Jeśli komuś to wysłałeś np. poprzez aplikację, która ma serwer poza granicami Polski, to możliwe, że już doszło do złamania prawa.

Ale nie musiało tak być, bo wszystko zależy od tego, co wysłałeś i czy w ogóle można to klasyfikować jako przedmiot podwójnego użycia.

---

nie chce mi się dalej sprawdzać robienie do około 40 liczby zajmuje około 30 min jak "na razie nigdy się nie pomyliło" zawsze wskazuje liczbę pierwszą i żadnej innej. co do skryptów to jestem zielony musiał bym się uczyć - pokazałem to znajomemu z FB i okazało się że trochę programuje więc może on jakiś algorytm stworzy plus dał mi namiary na matematyka który może będzie zainteresowany. no to prawo raczej już złamałem bo wysyłałem przez FB plik

---

Cokolwiek co napisałeś i jest sprawdzone "do 130" nie ma wartości. Jeśli masz coś co może szybko powiedzieć jaka jest 10**10 liczba pierwsza, albo czy liczba mająca kilkaset tysięcy cyfr jest pierwsza czy nie, to _może_ ma jakąś wartość.

Nawet nie wiem co może zabrać 30 minut z liczbami rzędu 200, przecież zwykłe policzenie czynników na kartce zajmie z minutę-dwie.

Po prostu to wrzuć publicznie. Z tak małymi liczbami to każda rzecz którą mogłeś wymyślić, gwarantuję że tysiące osób pomyślało przed Tobą.

---

jak to się nadaje to trzeba by było na podstawie tego napisać jakiś wzór lub algorytm ja zrobiłem to tak jak by graficznie i dlatego to tyle czasu zajmuje z tymi 30 min może przesadziłem powiedzmy że zajmuje to z 20 min z grubsza na podstawie ze zrobionego na kolanie i za pierwszym razem wskazuje przyszłe liczby pierwsze od 5 do 70 pozycji do przodu a zrobiłem to tylko do pozycji około 130 zakładam że jak mam rację to da radę z tego przewidywać większe liczby. jest też problem bo wskazuje mi liczbę 2 jako pierwszą łamiąc ogólną zasadę wskazującą liczby pierwsze i drugi problem bo wskazuje liczbę dwa gdzie "nie może" jej wskazać (może dlatego że jest parzysta) bo łamie pewną zasadę (problem jest z ~trzema pierwszymi liczbami) wszystkie inne około 30 pozycji wskazuje poprawnie i tylko pierwsze żadnych innych. mam nadzieję że nawet jak by to nie działało w 100% to że na podstawie tego posunie to do przodu badania nad liczbami pierwszymi. wpadnięcie na to zajęło mi około 20 roboczo godzin i nie mam już weny twórczej aby to dalej "badać" i chciał bym to komuś  przedstawić kto potwierdzi lub wskaże błędy lub sam to dokończy

Answer 3

PRAWO MART'a: "O TYM CZY DANA KOLEJNA LICZBA NIEPARZYSTA JEST PIERWSZĄ, NIE DECYDUJE PRZYPADKOWOŚĆ, LECZ LICZBA PARZYSTA, WYSTĘPUJĄCA BEZPOŚREDNIO PRZED NIĄ. OWA LICZBA PARZYSTA ZBUDOWANA JEST Z KONKRETNYCH NIEPRZYPADKOWYCH DWÓCH LICZB NATURALNYCH, KTÓRE STANOWIĄ RÓŻNICĘ INNYCH LICZB NIEPRZYPADKOWYCH PIERWSZYCH POMNIEJSZONYCH O 1." 

WZÓR :(Lp1-1)+(Lp2-1)=(Lp3-1)

"Co do samego pytania, jako iż nie jestem Matematykiem, nawet nie próbuje go zrozumieć?"

"Test Pierwszeństwa Mart'a Parzyste/Nieparzyste "

def f(L):
    return L - sum(L // k for k in range(2, L + 1))
print("Budowa i rozmieszczenie Liczb Pierwszych wg.Mart'a")

# "Probably prime" if f(L) == f(L-1)
def is_probably_prime(L):
    return f(L) == f(L - 1)

# Przykładowe testy z oznaczeniami
for L in range(1, 100):
    fl = f(L)
    fl_prev = f(L - 1)
    delta = fl - fl_prev
    prime_test = is_probably_prime(L)
    symbol = "✅" if prime_test else "❌"
    print(f"L = {L:2}, f(L) = {fl:4}, f(L-1) = {fl_prev:4}, Δ = {delta:3}, Prime? {symbol}")

Budowa i rozmieszczenie Liczb Pierwszych wg.Mart'a
L =  1, f(L) =    1, f(L-1) =    0, Δ =   1, Prime? ❌
L =  2, f(L) =    1, f(L-1) =    1, Δ =   0, Prime? ✅
L =  3, f(L) =    1, f(L-1) =    1, Δ =   0, Prime? ✅
L =  4, f(L) =    0, f(L-1) =    1, Δ =  -1, Prime? ❌
L =  5, f(L) =    0, f(L-1) =    0, Δ =   0, Prime? ✅
L =  6, f(L) =   -2, f(L-1) =    0, Δ =  -2, Prime? ❌
L =  7, f(L) =   -2, f(L-1) =   -2, Δ =   0, Prime? ✅
L =  8, f(L) =   -4, f(L-1) =   -2, Δ =  -2, Prime? ❌
L =  9, f(L) =   -5, f(L-1) =   -4, Δ =  -1, Prime? ❌
L = 10, f(L) =   -7, f(L-1) =   -5, Δ =  -2, Prime? ❌
L = 11, f(L) =   -7, f(L-1) =   -7, Δ =   0, Prime? ✅
L = 12, f(L) =  -11, f(L-1) =   -7, Δ =  -4, Prime? ❌
L = 13, f(L) =  -11, f(L-1) =  -11, Δ =   0, Prime? ✅
L = 14, f(L) =  -13, f(L-1) =  -11, Δ =  -2, Prime? ❌
L = 15, f(L) =  -15, f(L-1) =  -13, Δ =  -2, Prime? ❌
L = 16, f(L) =  -18, f(L-1) =  -15, Δ =  -3, Prime? ❌
L = 17, f(L) =  -18, f(L-1) =  -18, Δ =   0, Prime? ✅
L = 18, f(L) =  -22, f(L-1) =  -18, Δ =  -4, Prime? ❌
L = 19, f(L) =  -22, f(L-1) =  -22, Δ =   0, Prime? ✅
L = 20, f(L) =  -26, f(L-1) =  -22, Δ =  -4, Prime? ❌
L = 21, f(L) =  -28, f(L-1) =  -26, Δ =  -2, Prime? ❌
L = 22, f(L) =  -30, f(L-1) =  -28, Δ =  -2, Prime? ❌
L = 23, f(L) =  -30, f(L-1) =  -30, Δ =   0, Prime? ✅
L = 24, f(L) =  -36, f(L-1) =  -30, Δ =  -6, Prime? ❌
L = 25, f(L) =  -37, f(L-1) =  -36, Δ =  -1, Prime? ❌
L = 26, f(L) =  -39, f(L-1) =  -37, Δ =  -2, Prime? ❌
L = 27, f(L) =  -41, f(L-1) =  -39, Δ =  -2, Prime? ❌
L = 28, f(L) =  -45, f(L-1) =  -41, Δ =  -4, Prime? ❌
L = 29, f(L) =  -45, f(L-1) =  -45, Δ =   0, Prime? ✅
L = 30, f(L) =  -51, f(L-1) =  -45, Δ =  -6, Prime? ❌
L = 31, f(L) =  -51, f(L-1) =  -51, Δ =   0, Prime? ✅
L = 32, f(L) =  -55, f(L-1) =  -51, Δ =  -4, Prime? ❌
L = 33, f(L) =  -57, f(L-1) =  -55, Δ =  -2, Prime? ❌
L = 34, f(L) =  -59, f(L-1) =  -57, Δ =  -2, Prime? ❌
L = 35, f(L) =  -61, f(L-1) =  -59, Δ =  -2, Prime? ❌
L = 36, f(L) =  -68, f(L-1) =  -61, Δ =  -7, Prime? ❌
L = 37, f(L) =  -68, f(L-1) =  -68, Δ =   0, Prime? ✅
L = 38, f(L) =  -70, f(L-1) =  -68, Δ =  -2, Prime? ❌
L = 39, f(L) =  -72, f(L-1) =  -70, Δ =  -2, Prime? ❌
L = 40, f(L) =  -78, f(L-1) =  -72, Δ =  -6, Prime? ❌
L = 41, f(L) =  -78, f(L-1) =  -78, Δ =   0, Prime? ✅
L = 42, f(L) =  -84, f(L-1) =  -78, Δ =  -6, Prime? ❌
L = 43, f(L) =  -84, f(L-1) =  -84, Δ =   0, Prime? ✅
L = 44, f(L) =  -88, f(L-1) =  -84, Δ =  -4, Prime? ❌
L = 45, f(L) =  -92, f(L-1) =  -88, Δ =  -4, Prime? ❌
L = 46, f(L) =  -94, f(L-1) =  -92, Δ =  -2, Prime? ❌
L = 47, f(L) =  -94, f(L-1) =  -94, Δ =   0, Prime? ✅
L = 48, f(L) = -102, f(L-1) =  -94, Δ =  -8, Prime? ❌
L = 49, f(L) = -103, f(L-1) = -102, Δ =  -1, Prime? ❌
L = 50, f(L) = -107, f(L-1) = -103, Δ =  -4, Prime? ❌
L = 51, f(L) = -109, f(L-1) = -107, Δ =  -2, Prime? ❌
L = 52, f(L) = -113, f(L-1) = -109, Δ =  -4, Prime? ❌
L = 53, f(L) = -113, f(L-1) = -113, Δ =   0, Prime? ✅
L = 54, f(L) = -119, f(L-1) = -113, Δ =  -6, Prime? ❌
L = 55, f(L) = -121, f(L-1) = -119, Δ =  -2, Prime? ❌
L = 56, f(L) = -127, f(L-1) = -121, Δ =  -6, Prime? ❌
L = 57, f(L) = -129, f(L-1) = -127, Δ =  -2, Prime? ❌
L = 58, f(L) = -131, f(L-1) = -129, Δ =  -2, Prime? ❌
L = 59, f(L) = -131, f(L-1) = -131, Δ =   0, Prime? ✅
L = 60, f(L) = -141, f(L-1) = -131, Δ = -10, Prime? ❌
L = 61, f(L) = -141, f(L-1) = -141, Δ =   0, Prime? ✅
L = 62, f(L) = -143, f(L-1) = -141, Δ =  -2, Prime? ❌
L = 63, f(L) = -147, f(L-1) = -143, Δ =  -4, Prime? ❌
L = 64, f(L) = -152, f(L-1) = -147, Δ =  -5, Prime? ❌
L = 65, f(L) = -154, f(L-1) = -152, Δ =  -2, Prime? ❌
L = 66, f(L) = -160, f(L-1) = -154, Δ =  -6, Prime? ❌
L = 67, f(L) = -160, f(L-1) = -160, Δ =   0, Prime? ✅
L = 68, f(L) = -164, f(L-1) = -160, Δ =  -4, Prime? ❌
L = 69, f(L) = -166, f(L-1) = -164, Δ =  -2, Prime? ❌
L = 70, f(L) = -172, f(L-1) = -166, Δ =  -6, Prime? ❌
L = 71, f(L) = -172, f(L-1) = -172, Δ =   0, Prime? ✅
L = 72, f(L) = -182, f(L-1) = -172, Δ = -10, Prime? ❌
L = 73, f(L) = -182, f(L-1) = -182, Δ =   0, Prime? ✅
L = 74, f(L) = -184, f(L-1) = -182, Δ =  -2, Prime? ❌
L = 75, f(L) = -188, f(L-1) = -184, Δ =  -4, Prime? ❌
L = 76, f(L) = -192, f(L-1) = -188, Δ =  -4, Prime? ❌
L = 77, f(L) = -194, f(L-1) = -192, Δ =  -2, Prime? ❌
L = 78, f(L) = -200, f(L-1) = -194, Δ =  -6, Prime? ❌
L = 79, f(L) = -200, f(L-1) = -200, Δ =   0, Prime? ✅
L = 80, f(L) = -208, f(L-1) = -200, Δ =  -8, Prime? ❌
L = 81, f(L) = -211, f(L-1) = -208, Δ =  -3, Prime? ❌
L = 82, f(L) = -213, f(L-1) = -211, Δ =  -2, Prime? ❌
L = 83, f(L) = -213, f(L-1) = -213, Δ =   0, Prime? ✅
L = 84, f(L) = -223, f(L-1) = -213, Δ = -10, Prime? ❌
L = 85, f(L) = -225, f(L-1) = -223, Δ =  -2, Prime? ❌
L = 86, f(L) = -227, f(L-1) = -225, Δ =  -2, Prime? ❌
L = 87, f(L) = -229, f(L-1) = -227, Δ =  -2, Prime? ❌
L = 88, f(L) = -235, f(L-1) = -229, Δ =  -6, Prime? ❌
L = 89, f(L) = -235, f(L-1) = -235, Δ =   0, Prime? ✅
L = 90, f(L) = -245, f(L-1) = -235, Δ = -10, Prime? ❌
L = 91, f(L) = -247, f(L-1) = -245, Δ =  -2, Prime? ❌
L = 92, f(L) = -251, f(L-1) = -247, Δ =  -4, Prime? ❌
L = 93, f(L) = -253, f(L-1) = -251, Δ =  -2, Prime? ❌
L = 94, f(L) = -255, f(L-1) = -253, Δ =  -2, Prime? ❌
L = 95, f(L) = -257, f(L-1) = -255, Δ =  -2, Prime? ❌
L = 96, f(L) = -267, f(L-1) = -257, Δ = -10, Prime? ❌
L = 97, f(L) = -267, f(L-1) = -267, Δ =   0, Prime? ✅
L = 98, f(L) = -271, f(L-1) = -267, Δ =  -4, Prime? ❌
L = 99, f(L) = -275, f(L-1) = -271, Δ =  -4, Prime? ❌

Gdybym Tylko Znał Wzór na te Sumy, to obliczył bym najprawdopodobniej Każdą Liczbę Pierwszą?

"Po prostu nie chciałem tworzyć nowego Pytania He He"

Comments

jak sądzicie-> czy publikowalibyście publicznie rozmieszczenie liczb pierwszych (załóżmy że ktoś ma rację co do ich rozmieszczenia) czy należy być z tym ostrożnym bo używa ich wojsko i banki (sorry za drugi raz zadanie pytania ale jednoznacznej odpowiedzi nie uzyskałem)

---

CosmoWielki,

Na oko to ta definicja/algorytm jest równoważna zwykłej definicji/testowi "czy jest niepodzielna przez wszystkie liczby poza sobą i 1" (bo skoro jest niepodzielna, to liczba o 1 mniejsza będzie mieć te same wartości floor(L/k) ). No i też wydajnościowo (w sensie złożoności czasowej algorytmu, nie wydajności Pythona) gorszy od standardowego naiwnego testu podzielności typu

all(n % i != 0 for i in range(2, int(n**0.5) + 1))

Taki test podzielności każdy umie zrobić bez problemu; to że możesz go zrobić i teoretycznie możesz go wykonać na dowolnie dużej liczbie, nie oznacza że w ten sposób "możesz poznać każdą liczbę pierwszą", bo to się nie skaluje dla liczb które mają np 40 milionów cyfr (a takie liczby pierwsze znamy).

---

"Wiedząc dlaczego Liczba 2,3,5 jest Pierwsza i Kiedy, może ja nie potwierdzę czy te  40 milionów cyfr to Liczba Pierwsza, 

ale Taki Super Mózg, to już tak....."

Struktura Liczb Pierwszych ws Złożonych wg.Mart'a
Porównanie składników dla L = 15 i L-1 = 14:

k =  2: (L-1)//k =   7, L//k =   7  ✅
k =  3: (L-1)//k =   4, L//k =   5  ❌

Pierwsza różnica pojawia się przy k = 3: 4 vs 5

k =  4: (L-1)//k =   3, L//k =   3  ✅
k =  5: (L-1)//k =   2, L//k =   3  ❌
k =  6: (L-1)//k =   2, L//k =   2  ✅
k =  7: (L-1)//k =   2, L//k =   2  ✅
k =  8: (L-1)//k =   1, L//k =   1  ✅
k =  9: (L-1)//k =   1, L//k =   1  ✅
k = 10: (L-1)//k =   1, L//k =   1  ✅
k = 11: (L-1)//k =   1, L//k =   1  ✅
k = 12: (L-1)//k =   1, L//k =   1  ✅
k = 13: (L-1)//k =   1, L//k =   1  ✅
k = 14: (L-1)//k =   1, L//k =   1  ✅
k = 15: (L-1)//k =   0, L//k =   1  ❌
————————————————————————————————————————
Suma składników dla L = 15:     30
Suma składników dla L-1 = 14: 27
f(L)   = 15 - 30     = -15
f(L-1) = 14 - 27 = -13
————————————————————————————————————————
❌ Wartości f różnią się ⇒ L = 15 to liczba złożona.

Porównanie składników dla L = 17 i L-1 = 16:

k =  2: (L-1)//k =   8, L//k =   8  ✅
k =  3: (L-1)//k =   5, L//k =   5  ✅
k =  4: (L-1)//k =   4, L//k =   4  ✅
k =  5: (L-1)//k =   3, L//k =   3  ✅
k =  6: (L-1)//k =   2, L//k =   2  ✅
k =  7: (L-1)//k =   2, L//k =   2  ✅
k =  8: (L-1)//k =   2, L//k =   2  ✅
k =  9: (L-1)//k =   1, L//k =   1  ✅
k = 10: (L-1)//k =   1, L//k =   1  ✅
k = 11: (L-1)//k =   1, L//k =   1  ✅
k = 12: (L-1)//k =   1, L//k =   1  ✅
k = 13: (L-1)//k =   1, L//k =   1  ✅
k = 14: (L-1)//k =   1, L//k =   1  ✅
k = 15: (L-1)//k =   1, L//k =   1  ✅
k = 16: (L-1)//k =   1, L//k =   1  ✅
k = 17: (L-1)//k =   0, L//k =   1  ❌

Pierwsza różnica pojawia się przy k = 17: 0 vs 1

————————————————————————————————————————
Suma składników dla L = 17:     35
Suma składników dla L-1 = 16: 34
f(L)   = 17 - 35     = -18
f(L-1) = 16 - 34 = -18
————————————————————————————————————————
✅ Wartości f są równe ⇒ L = 17 to prawdopodobnie liczba pierwsza.

Python Program:

def pierwsza_roznica(L):
    suma_L = 0
    suma_L_minus_1 = 0
    found_difference = False

    print(f"Porównanie składników dla L = {L} i L-1 = {L-1}:\n")
    for k in range(2, L + 1):
        a = (L - 1) // k
        b = L // k
        suma_L_minus_1 += a
        suma_L += b
        znak = "✅" if a == b else "❌"
        print(f"k = {k:>2}: (L-1)//k = {a:>3}, L//k = {b:>3}  {znak}")
        if not found_difference and a != b:
            print(f"\n Pierwsza różnica pojawia się przy k = {k}: {a} vs {b}\n")
            found_difference = True

    f_L = L - suma_L
    f_Lm1 = (L - 1) - suma_L_minus_1

    print("—" * 40)
    print(f"Suma składników dla L = {L}:     {suma_L}")
    print(f"Suma składników dla L-1 = {L-1}: {suma_L_minus_1}")
    print(f"f(L)   = {L} - {suma_L}     = {f_L}")
    print(f"f(L-1) = {L-1} - {suma_L_minus_1} = {f_Lm1}")
    print("—" * 40)

    if f_L == f_Lm1:
        print(f"✅ Wartości f są równe ⇒ L = {L} to prawdopodobnie liczba pierwsza.")
    else:
        print(f"❌ Wartości f różnią się ⇒ L = {L} to liczba złożona.")

# Przykłady:
print("Struktura Liczb Pierwszych ws Złożonych wg.Mart'a")
pierwsza_roznica(15)
print("\n")
pierwsza_roznica(17)

"Wystarczy By Stworzył wzór na te SUMY???

---

Takie tam dwa testy, niestety obie korzystają z potęgowania modularnego, trochę szybsze"!!! Probabilistyczny test Mart’a (wariacja Fermata) !!!"

 

Kod Pierwszy:

import sys
import random

sys.set_int_max_str_digits(50000)

def mart_f(L, k):
    """Eksperymentalna funkcja Mart'a – wersja z modyfikacjami"""
    return pow(k, L - 1, L)

def mart_test(L, rounds=5):
    """Probabilistyczny test Mart’a z losowymi k"""
    if L == 2 or L == 3:
       return True
    if L < 5 or L % 2 == 0:
        return False

    for _ in range(rounds):
        k = random.randint(2, L - 2)
        if mart_f(L, k) != 1:
            return False
    return True

# === Główna sekcja programu ===
print("-------------------------------------------------------")
print("!!! Probabilistyczny test Mart’a (wariacja Fermata) !!!")
print("---------- WYŚWIETLANIE TYLKO LICZB PIERWSZYCH --------")

try:
    start = int(input("Podaj liczbę początkową do sprawdzenia (start): "))
    count = int(input("Podaj ilość kolejnych liczb do sprawdzenia (N): "))

    if start < 1 or count < 1:
        raise ValueError("Obie liczby muszą być większe od zera.")

    for L in range(start, start + count):
        if mart_test(L):
            print(f"{L} ✅")

except ValueError as e:
    print(f"Błąd: {e}")

 

Kod drugi :

 

import sys
import random

sys.set_int_max_str_digits(50000)

def mart_f_inverse_compare(L, k):
    """Zwraca |k - k^(-1) mod L| jeśli odwrotność istnieje, w przeciwnym wypadku L"""
    try:
        inv = pow(k, -1, L)
        return abs(k * inv)
    except ValueError:
        return L  # brak odwrotności → liczba złożona

def mart_test_fermat_variant(L, rounds=5):
    if L in (2, 3):
        return True
    if L < 5 or L % 2 == 0:
        return False

    for _ in range(rounds):
        k = random.randint(2, L - 2)
        if pow(k, L- 1, L) != 1:
            return False  # klasyczny test Fermata nie przeszedł
        try:
            inv = pow(k, -1, L)
        except ValueError:
            return False  # brak odwrotności modularnej → L złożona
        if abs(k - inv) <= 1:
            return False  # podejrzanie symetryczna odwrotność
    return True

# === Główna sekcja programu ===
print("-------------------------------------------------------")
print("!!! Probabilistyczny test Mart’a (wariacja odwrotności) !!!")
print("-------------------------------------------------------")

try:
    start = int(input("Podaj liczbę początkową do sprawdzenia (start): "))
    count = int(input("Podaj ilość kolejnych liczb do sprawdzenia (N): "))

    if start < 1 or count < 1:
        raise ValueError("Obie liczby muszą być większe od zera.")

    for L in range(start, start + count):
        if mart_test_fermat_variant(L):
            print(f"{L} ✅")

except ValueError as e:
    print(f"Błąd: {e}")

"#### Test Mart'a „rękawiczka” (Miller-Rabin) ####"

import math
import random

# prawa „rękawiczka”  – pojedyncza runda Millera–Rabina
def glove_right(n: int, k: int = 1) -> bool:
    if n == 2 or n == 3:
        return True
    d, r = n - 1, 0
    while d % 2 == 0:
        d //= 2
        r += 1
    for _ in range(k):
        a = random.randint(2, n - 2)
        x = pow(math.isqrt(n * a) * a, d, n)
        if x in (1, n - 1):
            continue
        for _ in range(r - 1):
            x = pow(x, 2, n)
            if x == n - 1:
                break
        else:
            return False
    return True

# lewa „rękawiczka”  – ta sama procedura, ale...
def glove_left(n: int, k: int = 1) -> bool:
    if n == 2 or n == 3:
        return True
    d, r = n - 1, 0
    while d % 2 == 0:
        d //= 2
        r += 1
    for _ in range(k):
        a = random.randint(2, n - 2)
        x = pow(math.isqrt(n * a) * a, d, n)
        if x in (1, n - 1):
            continue
        for _ in range(r - 1):
            x = pow(x, 2, n)
            if x == n - 1:
                break
        else:
            return False
    return True

# klasyfikator wykorzystujący oba testy
print("#### Test Mart'a „rękawiczka” (Miller-Rabin) ####")
def classify_number(n: int, k: int = 1, verbose: bool = False) -> str:
    right  = glove_right(n, k)
    left   = glove_left(n, k)
    score  = int(right) + int(left)          # 0, 1 lub 2

    if score == 2:
        if verbose:
            print(f"{n} → ✅ pierwsza  (score=2, R={right}, L={left})")
        return "prime"
    else:
        if verbose:
            kind = "⚠️ złożona (score=1)" if score == 1 else "❌ złożona (score=0)"
            print(f"{n} → {kind} (R={right}, L={left})")
        return "composite"

# --- demonstracja 2-100 ----------------------------------------------------
for N in range(2, 102):
    classify_number(N, k=1, verbose=True)
print("#### Test Mart'a „rękawiczka” (Miller-Rabin) ####")