From 0eb727299b072af3b6c82fd4b48e89eb4af45837 Mon Sep 17 00:00:00 2001
From: nashmiak <64479941+nashmiak@users.noreply.github.com>
Date: Tue, 28 Apr 2020 10:34:24 -0400
Subject: [PATCH] Delete Primes

---
 Primes | 444 ---------------------------------------------------------
 1 file changed, 444 deletions(-)
 delete mode 100644 Primes

diff --git a/Primes b/Primes
deleted file mode 100644
index 3390927..0000000
--- a/Primes
+++ /dev/null
@@ -1,444 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Nashmia Khan\n",
-    "\n",
-    "MTH337- Project 1"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Introduction\n",
-    "\n",
-    "A *prime number* is defined as an integer greater than 1 that can only be divisible by 1 and itself. Prime numbers can be used in various encryptions and codes to represent and transmit certain data, which is why defining and recognizing prime numbers is crucial in the real world. Prime numbers can be recognized easily when they are being related with congruences. In doing so, it can be seen that when given a prime number, *p*, it holds true that \n",
-    "$$ a^p\\equiv a (mod p)$$ for any integer $0<a<p $\n",
-    "\n",
-    "This theroem makes the recognition of a prime number more prominent. Some integers, however, can be interpreted as *false primes*.\n",
-    "\n",
-    "In this case, a number, *p*, is not a prime number, but the theorem above will still hold true. The number, *p*, becomes a false prime as long as p is greater than or equal to 2. Although the theorem holds true in recognizing prime numbers for an infinite amount of integers, an infinite amount of those integers could indeed be false primes as well.\n",
-    "\n",
-    "The goal of this project is to recognize the first twenty false primes that come about from this theorem. By mainly focusing on the numbers that are *prime-like* to see which integers satisfy the theorem, from those prime-like numbers will it be easier to recognize and check to see which numbers are prime, and which are not."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Part 1"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 54,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def isprime2(n): # This function will return your desired number, n, and recognize it as a prime number as a boolean expression.\n",
-    "    prime=True \n",
-    "    if n<2: # A prime number, n, must follow the condition that it is greater than 2, if not, it will return False\n",
-    "        prime=False\n",
-    "    for k in range(2,n): # A prime number must have a remainder, if it does not, then it will return False\n",
-    "        if n%k==0:\n",
-    "            prime=False\n",
-    "            break\n",
-    "    return prime # If these conditions are met, your desired number, n, is a prime number and will return True"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 29,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "False"
-      ]
-     },
-     "execution_count": 29,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "isprime2(561)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 30,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "False"
-      ]
-     },
-     "execution_count": 30,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "isprime2(24)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 56,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def congr_test_p(p): # This function determines whether an integer, p, is primelike given the following conditions, returning a boolean expression.\n",
-    "    for a in range(2,p): # The range must be greater than 2, but below the integer, p.\n",
-    "        if pow(a,p,p)!=a%p: # This function computes the congruency between the integer and it's modulus within the range, if the integer fails this test, then it will return false, concluding that it is not primelike. \n",
-    "            return False\n",
-    "    return True # If these conditions are met, then the function will return true, concluding that it is primelike."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 32,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "False"
-      ]
-     },
-     "execution_count": 32,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "a = 10\n",
-    "congr_test_p(a)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 57,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def falseprime(n): # This function uses a Boolean to determine whether an integer is a falseprime or not\n",
-    "    if((not isprime2(n))and congr_test_p(n)): # In order to be a falseprime, the integer must not be a prime number, but it must satisfy the congruency test.  \n",
-    "        return True # If an integer follows the above conditions, it is a falseprime and will return True.\n",
-    "    return False # If an integer is prime and passes the congruency test, it is not a falseprime and will return False."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 34,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True"
-      ]
-     },
-     "execution_count": 34,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "falseprime(561)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 35,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "False"
-      ]
-     },
-     "execution_count": 35,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "falseprime(560)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "False"
-      ]
-     },
-     "execution_count": 36,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "falseprime(7)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 64,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[561, 1105, 1729, 2465, 2821, 6601, 8911, 10585, 15841, 29341, 41041, 46657, 52633, 62745, 63973, 75361, 101101, 115921, 126217, 162401]\n"
-     ]
-    }
-   ],
-   "source": [
-    "mylist=[] # This empty list will contain my list of false primes\n",
-    "n=2\n",
-    "\n",
-    "\n",
-    "while len(mylist)<20: # Restricts the list of false primes to only output the first 20\n",
-    "    if falseprime(n)==True: \n",
-    "        mylist.append(n) # Only the integers that satisfy the above definition of a false prime will be added to this list.\n",
-    "    n=n+1\n",
-    "print(mylist) # Prints a list of the first 20 false primes."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Part 2"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 67,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def myprimes2(n): # This function returns all of the prime numbers less than the desired integer, n\n",
-    "    numlist=[] # Gives the prime numbers less than n in a numbered list\n",
-    "    for x in range(n+1):\n",
-    "        if isprime2(x):\n",
-    "            numlist.append(x) # Adds the next consecutive prime number less than n to the end of the numbered list\n",
-    "    return numlist # Returns the numbered list of prime numbers less than desired integer, n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 39,
-   "metadata": {
-    "scrolled": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[2, 3, 5, 7]\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(myprimes2(7))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 40,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(myprimes2(50))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 63,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def primary(n): # This function gives the primary decomposition of an integer, n, in a factored list.\n",
-    "    factorlist=[]\n",
-    "    myprimes2(n)\n",
-    "    for k in myprimes2(n):\n",
-    "        while n%k==0:\n",
-    "            factorlist.append(k) \n",
-    "            n=n/k # This condition further decomposes any integers within the factored list to ensure the factors are fully decomposed.\n",
-    "        if n==1:\n",
-    "            break # Once the integer can no longer be decomposed any further, it will break.\n",
-    "    return factorlist # Returns the primary decomposition of an integer, n, in list form."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 42,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[7]"
-      ]
-     },
-     "execution_count": 42,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "primary(7)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 43,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[2, 2, 3]"
-      ]
-     },
-     "execution_count": 43,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "primary(12)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 44,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[3, 11, 17]"
-      ]
-     },
-     "execution_count": 44,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "primary(561)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 66,
-   "metadata": {
-    "scrolled": false
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[[3, 11, 17], [5, 13, 17], [7, 13, 19], [5, 17, 29], [7, 13, 31], [7, 23, 41], [7, 19, 67], [5, 29, 73], [7, 31, 73], [13, 37, 61], [7, 11, 13, 41], [13, 37, 97], [7, 73, 103], [3, 5, 47, 89], [7, 13, 19, 37], [11, 13, 17, 31], [7, 11, 13, 101], [13, 37, 241], [7, 13, 19, 73], [17, 41, 233]]\n"
-     ]
-    }
-   ],
-   "source": [
-    "mylist=[561, 1105, 1729, 2465, 2821, 6601, 8911, 10585, 15841, 29341, 41041, 46657, 52633, 62745, 63973, 75361, 101101, 115921, 126217, 162401]\n",
-    "primedecomplist=[primary(n) for n in mylist] # This list returns the primary decomposition in list form of each false prime within mylist consecutively. \n",
-    "\n",
-    "print(primedecomplist)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Part 3"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The properties of false primes consist of various characteristics that are carried out and can be inferred within my list of false primes. The numbers in this list are composite and are also pseudoprime, since these numbers are not prime and pass the congruence test, while other composite numbers fail. Furthermore, every false prime number is squarefree, meaning each integer in the lists containing the primary decomposition of the false primes cannot be square rooted or broken down any further. There are many characteristics that can be inferred about the primary decomposition of the false primes as well.\n",
-    "\n",
-    "Every list consisting of the primary decomposition of each false prime only contains 3-4 prime numbers. This might be because of the fact that as the falseprime list increases, the rarity of each false prime increases too, resulting in larger prime numbers being used to satisfy the decomposition of each falseprime. Lastly, each integer used to determine the primary decompositions of the falseprimes are all prime numbers greater than 2 and include 3 or more prime factors. "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Conclusion"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Prime numbers are very significant when trying to represent and transmit data, and that is why it is important to detect the false primes that could miscontrue a code and falsify your information. As can be seen, there are in fact infinitely many false primes that can be discovered when inputting your desired data through different functions. \n",
-    "\n",
-    "The functions incorporated with detecting the false primes and processing the data to factor out these integers include having to define a false prime, while formulating the different definitions needed to meet the conditions of it. These included my definitions: `isprime2(n)` and `congr_test_p(p)`. Following the definition of a false prime, since this project focused on only the first 20 false primes, a list is then formulated to contain these 20 integers.\n",
-    "\n",
-    "Once the first 20 false primes have been discovered, in order to check if the integers are truly false primes we must find the primary decomposition of each integer within the list of false primes using the addition of two more definitions:\n",
-    "`myprimes2(n)` and `primary(n)`. The definition `myprimes2(n)` consists of the prime numbers less than any given integer in a listed form, and `primary(n)` returning a factored list of the primary decomposition of your desired number. Finally, in order to compose the primary decomposition of the first 20 false primes, a `primedecomplist` is created to store the factors of each false prime derived from the two concepts that a falseprime is not a prime number, but that it satisfies the theorem: $$ a^p\\equiv a (mod p)$$ for any integer $0<a<p $."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}