# polynomials

Published articles for polynomials.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## CKKS -- Polynomials, the Canonical Embedding, and Encoding

DevFeed: [CKKS -- Polynomials, the Canonical Embedding, and Encoding](<https://devfeed.tech/articles/ckks-polynomials-the-canonical-embedding-and-encoding-40495.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2026/04/29/ckks-polynomials-the-canonical-embedding-and-encoding/>)

Published: 2026-04-29T12:25:44Z

Content type: tutorial

Language: en

Sources: [Jeremy Kun](<https://devfeed.tech/sources/jeremy-kun.md>)

Topics: [homomorphic encryption](<https://devfeed.tech/topics/homomorphic-encryption.md>), [Cryptography](<https://devfeed.tech/topics/cryptography.md>), [Mathematics](<https://devfeed.tech/topics/mathematics.md>), [Math and Logic](<https://devfeed.tech/topics/math-and-logic.md>)

Tags: [ckks](<https://devfeed.tech/tags/ckks.md>), [ckks-tutorial](<https://devfeed.tech/tags/ckks-tutorial.md>), [cryptography](<https://devfeed.tech/tags/cryptography.md>), [encoding](<https://devfeed.tech/tags/encoding.md>), [encryption](<https://devfeed.tech/tags/encryption.md>), [homomorphic-encryption](<https://devfeed.tech/tags/homomorphic-encryption.md>), [mathematics](<https://devfeed.tech/tags/mathematics.md>), [neural-network](<https://devfeed.tech/tags/neural-network.md>), [polynomial-ring](<https://devfeed.tech/tags/polynomial-ring.md>), [polynomials](<https://devfeed.tech/tags/polynomials.md>), [programming](<https://devfeed.tech/tags/programming.md>), [python](<https://devfeed.tech/tags/python.md>), [technical](<https://devfeed.tech/tags/technical.md>), [tutorial](<https://devfeed.tech/tags/tutorial.md>)

### AI overview

This tutorial introduces the CKKS homomorphic encryption scheme and develops mathematical background on the polynomial ring used in its basic formulation and the canonical embedding used to encode cleartext messages as plaintexts. It also outlines CKKS's history, including its support for approximate arithmetic and later bootstrapping improvements.

### Source excerpt

Table of Contents In this tutorial series, I will introduce the CKKS homomorphic encryption scheme from the ground up, in rather intricate detail. Each article in this series corresponds to a pull request on a GitHub repository. The code for this article is in this pull request. Follow along by cloning the repository and checking out the code at the relevant commit. This first article will cover some of the mathematical background necessary in the formulation of the CKKS encryption scheme, specifically the polynomial ring used in the most basic version of CKKS, and the canonical embedding used to encode cleartext messages as plaintexts.

## Remez and function approximations

DevFeed: [Remez and function approximations](<https://devfeed.tech/articles/remez-and-function-approximations-40500.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/shortform/2024-05-06-1018/>)

Published: 2024-05-06T17:18:29Z

Content type: article

Language: en

Sources: [Jeremy Kun](<https://devfeed.tech/sources/jeremy-kun.md>)

Topics: [FHE](<https://devfeed.tech/topics/fhe.md>), [homomorphic encryption](<https://devfeed.tech/topics/homomorphic-encryption.md>), [polynomials](<https://devfeed.tech/topics/polynomials.md>), [Algorithm](<https://devfeed.tech/topics/algorithm.md>), [Python](<https://devfeed.tech/topics/python.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [approximation](<https://devfeed.tech/tags/approximation.md>), [article](<https://devfeed.tech/tags/article.md>), [fhe](<https://devfeed.tech/tags/fhe.md>), [homomorphic-encryption](<https://devfeed.tech/tags/homomorphic-encryption.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [library](<https://devfeed.tech/tags/library.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [polynomials](<https://devfeed.tech/tags/polynomials.md>), [python](<https://devfeed.tech/tags/python.md>), [remez](<https://devfeed.tech/tags/remez.md>), [shortform](<https://devfeed.tech/tags/shortform.md>)

### AI overview

The article discusses approximating functions with low-degree polynomials for arithmetic fully homomorphic encryption. It examines lolremez, the Remez algorithm, Paterson-Stockmeyer evaluation, and a multi-interval Remez method for approximating discontinuous functions such as sign.

### Source excerpt

I've been learning recently about how to approximate functions by low-degree polynomials. This is useful in fully homomorphic encryption (FHE) in the context of "arithmetic FHE" (see my FHE overview article), where the computational model makes low-degree polynomials cheap to evaluate and non-polynomial functions expensive or impossible. In browsing the state of the art I came across two interesting things. The first is the software package lolremez that implements polynomial (and rational polynomial $f(x) / g(x)$) function approximation using the so-called Remez algorithm.

## MLIR -- Dialect Conversion

DevFeed: [MLIR -- Dialect Conversion](<https://devfeed.tech/articles/mlir-dialect-conversion-40479.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2023/10/23/mlir-dialect-conversion/>)

Published: 2023-10-23T06:00:00Z

Content type: tutorial

Language: en

Sources: [Jeremy Kun](<https://devfeed.tech/sources/jeremy-kun.md>)

Topics: [Tutorial](<https://devfeed.tech/topics/tutorial.md>)

Tags: [article](<https://devfeed.tech/tags/article.md>), [code](<https://devfeed.tech/tags/code.md>), [heir](<https://devfeed.tech/tags/heir.md>), [mathematics](<https://devfeed.tech/tags/mathematics.md>), [mlir](<https://devfeed.tech/tags/mlir.md>), [polynomial-ring](<https://devfeed.tech/tags/polynomial-ring.md>), [polynomials](<https://devfeed.tech/tags/polynomials.md>), [primer](<https://devfeed.tech/tags/primer.md>), [programming](<https://devfeed.tech/tags/programming.md>)

### AI overview

This tutorial introduces MLIR dialect conversion and incremental lowering, explaining how a custom dialect can be lowered to standard MLIR dialects. It focuses on the type obstacle: changing value types can temporarily invalidate downstream users, requiring special handling during conversion.

### Source excerpt

Table of Contents In previous articles we defined a dialect, and wrote various passes to optimize and canonicalize a program using that dialect. However, one of the main tenets of MLIR is "incremental lowering," the idea that there are lots of levels of IR granularity, and you incrementally lower different parts of the IR, only discarding information when it's no longer useful for optimizations. In this article we'll see the first step of that: lowering the poly dialect to a combination of standard MLIR dialects, using the so-called dialect conversion infrastructure to accomplish it.

## MLIR -- Canonicalizers and Declarative Rewrite Patterns

DevFeed: [MLIR -- Canonicalizers and Declarative Rewrite Patterns](<https://devfeed.tech/articles/mlir-canonicalizers-and-declarative-rewrite-patterns-40477.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2023/09/20/mlir-canonicalizers-and-declarative-rewrite-patterns/>)

Published: 2023-09-20T08:00:00Z

Content type: tutorial

Language: en

Sources: [Jeremy Kun](<https://devfeed.tech/sources/jeremy-kun.md>)

Topics: [Code](<https://devfeed.tech/topics/code.md>), [C++](<https://devfeed.tech/topics/c-plus-plus.md>), [Development](<https://devfeed.tech/topics/development.md>)

Tags: [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [canonicalization](<https://devfeed.tech/tags/canonicalization.md>), [compilers](<https://devfeed.tech/tags/compilers.md>), [complex-numbers](<https://devfeed.tech/tags/complex-numbers.md>), [declarative](<https://devfeed.tech/tags/declarative.md>), [deprecated](<https://devfeed.tech/tags/deprecated.md>), [maintenance](<https://devfeed.tech/tags/maintenance.md>), [mathematics](<https://devfeed.tech/tags/mathematics.md>), [mlir](<https://devfeed.tech/tags/mlir.md>), [polynomials](<https://devfeed.tech/tags/polynomials.md>), [primer](<https://devfeed.tech/tags/primer.md>), [programming](<https://devfeed.tech/tags/programming.md>), [rewrite](<https://devfeed.tech/tags/rewrite.md>), [tablegen](<https://devfeed.tech/tags/tablegen.md>), [test](<https://devfeed.tech/tags/test.md>)

### AI overview

This tutorial explains how to implement general canonicalization patterns in MLIR. It covers both C++ canonicalizers and declarative rewrite rules in TableGen, including an identity-based polynomial rewrite and its testing considerations.

### Source excerpt

Table of Contents In a previous article we defined folding functions, and used them to enable some canonicalization and the sccp constant propagation pass for the poly dialect. This time we'll see how to add more general canonicalization patterns. The code for this article is in this pull request, and as usual the commits are organized to be read in order. Why is Canonicalization Needed? MLIR provides folding as a mechanism to simplify an IR, which can result in simpler, more efficient ops (e.

## MLIR -- Defining a New Dialect

DevFeed: [MLIR -- Defining a New Dialect](<https://devfeed.tech/articles/mlir-defining-a-new-dialect-40471.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2023/08/21/mlir-defining-a-new-dialect/>)

Published: 2023-08-21T08:00:00Z

Content type: tutorial

Language: en

Sources: [Jeremy Kun](<https://devfeed.tech/sources/jeremy-kun.md>)

Topics: [Code generation](<https://devfeed.tech/topics/code-generation.md>), [Tutorial](<https://devfeed.tech/topics/tutorial.md>), [polynomials](<https://devfeed.tech/topics/polynomials.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [code-generation](<https://devfeed.tech/tags/code-generation.md>), [compilers](<https://devfeed.tech/tags/compilers.md>), [define](<https://devfeed.tech/tags/define.md>), [endif](<https://devfeed.tech/tags/endif.md>), [ifdef](<https://devfeed.tech/tags/ifdef.md>), [include](<https://devfeed.tech/tags/include.md>), [mathematics](<https://devfeed.tech/tags/mathematics.md>), [mlir](<https://devfeed.tech/tags/mlir.md>), [polynomials](<https://devfeed.tech/tags/polynomials.md>), [programming](<https://devfeed.tech/tags/programming.md>), [tablegen](<https://devfeed.tech/tags/tablegen.md>), [tutorial](<https://devfeed.tech/tags/tutorial.md>), [undef](<https://devfeed.tech/tags/undef.md>)

### AI overview

This tutorial explains how to define a new MLIR dialect for arithmetic on single-variable polynomials with 32-bit unsigned integer coefficients. It covers the design, an empty dialect, generated code, registration, and a simple custom type.

### Source excerpt

Table of Contents In the last article in the series, we migrated the passes we had written to use the tablegen code generation framework. That was a preface to using tablegen to define dialects. In this article we'll define a dialect that represents arithmetic on single-variable polynomials, with coefficients in $\mathbb{Z} / 2^{32} \mathbb{Z}$ (32-bit unsigned integers). The code for this article is in this pull request, and as usual the commits are organized to be read in order.

## Negacyclic Polynomial Multiplication

DevFeed: [Negacyclic Polynomial Multiplication](<https://devfeed.tech/articles/negacyclic-polynomial-multiplication-40460.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2022/12/09/negacyclic-polynomial-multiplication/>)

Published: 2022-12-09T13:35:45Z

Content type: tutorial

Language: en

Sources: [Jeremy Kun](<https://devfeed.tech/sources/jeremy-kun.md>)

Topics: [polynomials](<https://devfeed.tech/topics/polynomials.md>), [Cryptography](<https://devfeed.tech/topics/cryptography.md>), [homomorphic encryption](<https://devfeed.tech/topics/homomorphic-encryption.md>), [Encryption](<https://devfeed.tech/topics/encryption.md>), [Python](<https://devfeed.tech/topics/python.md>), [GitHub](<https://devfeed.tech/topics/github.md>)

Tags: [article](<https://devfeed.tech/tags/article.md>), [complex-twist](<https://devfeed.tech/tags/complex-twist.md>), [cryptography](<https://devfeed.tech/tags/cryptography.md>), [encryption](<https://devfeed.tech/tags/encryption.md>), [fourier-transform](<https://devfeed.tech/tags/fourier-transform.md>), [github](<https://devfeed.tech/tags/github.md>), [homomorphic-encryption](<https://devfeed.tech/tags/homomorphic-encryption.md>), [mathematics](<https://devfeed.tech/tags/mathematics.md>), [negacyclic](<https://devfeed.tech/tags/negacyclic.md>), [polynomial-ring](<https://devfeed.tech/tags/polynomial-ring.md>), [polynomials](<https://devfeed.tech/tags/polynomials.md>), [programming](<https://devfeed.tech/tags/programming.md>), [python](<https://devfeed.tech/tags/python.md>)

### AI overview

This tutorial explains three techniques for computing negacyclic polynomial products, including the simpler cyclic product as a precursor. It places these operations in the context of lattice cryptography and fully homomorphic encryption and provides Python code on GitHub.

### Source excerpt

In this article I'll cover three techniques to compute special types of polynomial products that show up in lattice cryptography and fully homomorphic encryption. Namely, the negacyclic polynomial product, which is the product of two polynomials in the quotient ring $\mathbb{Z}[x] / (x^N + 1)$. As a precursor to the negacyclic product, we'll cover the simpler cyclic product. All of the Python code written for this article is on GitHub.

## Polynomial Multiplication Using the FFT

DevFeed: [Polynomial Multiplication Using the FFT](<https://devfeed.tech/articles/polynomial-multiplication-using-the-fft-40459.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2022/11/16/polynomial-multiplication-using-the-fft/>)

Published: 2022-11-16T08:00:00Z

Content type: tutorial

Language: en

Sources: [Jeremy Kun](<https://devfeed.tech/sources/jeremy-kun.md>)

Topics: [polynomials](<https://devfeed.tech/topics/polynomials.md>), [Algorithm](<https://devfeed.tech/topics/algorithm.md>), [NumPy](<https://devfeed.tech/topics/numpy.md>), [Mathematics](<https://devfeed.tech/topics/mathematics.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [arrays](<https://devfeed.tech/tags/arrays.md>), [efficiently](<https://devfeed.tech/tags/efficiently.md>), [fft](<https://devfeed.tech/tags/fft.md>), [fourier-transform](<https://devfeed.tech/tags/fourier-transform.md>), [mathematics](<https://devfeed.tech/tags/mathematics.md>), [polynomial-interpolation](<https://devfeed.tech/tags/polynomial-interpolation.md>), [polynomials](<https://devfeed.tech/tags/polynomials.md>), [programming](<https://devfeed.tech/tags/programming.md>), [python](<https://devfeed.tech/tags/python.md>)

### AI overview

This tutorial explains how to multiply two polynomials efficiently using the Fast Fourier Transform. It contrasts the naive O(n^2) approach with polynomial interpolation, pointwise multiplication, and carefully chosen roots of unity that enable reusable computations.

### Source excerpt

Problem: Compute the product of two polynomials efficiently. Solution: import numpy from numpy.fft import fft, ifft def poly_mul(p1, p2): """Multiply two polynomials. p1 and p2 are arrays of coefficients in degree-increasing order. """ deg1 = p1.shape[0] - 1 deg2 = p1.shape[0] - 1 # Would be 2*(deg1 + deg2) + 1, but the next-power-of-2 handles the +1 total_num_pts = 2 * (deg1 + deg2) next_power_of_2 = 1 << (total_num_pts - 1).

## Boolean Logic in Polynomials

DevFeed: [Boolean Logic in Polynomials](<https://devfeed.tech/articles/boolean-logic-in-polynomials-40414.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2017/07/24/boolean-logic-in-quadratic-polynomials/>)

Published: 2017-07-24T09:00:38Z

Content type: tutorial

Language: en

Sources: [Jeremy Kun](<https://devfeed.tech/sources/jeremy-kun.md>)

Topics: [polynomials](<https://devfeed.tech/topics/polynomials.md>), [Math and Logic](<https://devfeed.tech/topics/math-and-logic.md>), [Optimization](<https://devfeed.tech/topics/optimization.md>)

Tags: [boolean](<https://devfeed.tech/tags/boolean.md>), [boolean-satisfiability](<https://devfeed.tech/tags/boolean-satisfiability.md>), [logic](<https://devfeed.tech/tags/logic.md>), [machine-learning](<https://devfeed.tech/tags/machine-learning.md>), [np-hard](<https://devfeed.tech/tags/np-hard.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [polynomials](<https://devfeed.tech/tags/polynomials.md>)

### AI overview

This tutorial shows how to represent Boolean logic formulas with polynomials by using multiplication for conjunction and 1 minus a variable for negation. It explains how the construction relates Boolean satisfiability to the hardness of multivariable polynomial root-finding and constrained polynomial optimization.

### Source excerpt

Problem: Express a boolean logic formula using polynomials. I.e., if an input variable $ x$ is set to $ 0$, that is interpreted as false, while $ x=1$ is interpreted as true. The output of the polynomial should be 0 or 1 according to whether the formula is true or false as a whole. Solution: You can do this using a single polynomial. Illustrating with an example: the formula is $ \neg[(a \vee b) \wedge (\neg c \vee d)]$ also known as

## Testing Polynomial Equality

DevFeed: [Testing Polynomial Equality](<https://devfeed.tech/articles/testing-polynomial-equality-40409.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2017/04/24/testing-polynomial-equality/>)

Published: 2017-04-24T09:00:14Z

Content type: tutorial

Language: en

Sources: [Jeremy Kun](<https://devfeed.tech/sources/jeremy-kun.md>)

Topics: [Testing](<https://devfeed.tech/topics/testing.md>), [function](<https://devfeed.tech/topics/function.md>)

Tags: [field](<https://devfeed.tech/tags/field.md>), [function](<https://devfeed.tech/tags/function.md>), [polynomials](<https://devfeed.tech/tags/polynomials.md>), [random](<https://devfeed.tech/tags/random.md>), [roots](<https://devfeed.tech/tags/roots.md>), [testing](<https://devfeed.tech/tags/testing.md>), [variables](<https://devfeed.tech/tags/variables.md>)

### AI overview

The article explains how to test whether two multivariable polynomial expressions represent the same function. It presents randomized evaluation over a finite subset of a field and uses the Schwartz-Zippel lemma to bound the probability of an incorrect equality judgment.

### Source excerpt

Problem: Determine if two polynomial expressions represent the same function. Specifically, if $ p(x_1, x_2, \dots, x_n)$ and $ q(x_1, x_2, \dots, x_n)$ are a polynomial with inputs, outputs and coefficients in a field $ F$, where $ |F|$ is sufficiently large, then the problem is to determine if $ p(\mathbf{x}) = q(\mathbf{x})$ for every $ x \in F$, in time polynomial in the number of bits required to write down $ p$ and $ q$.

## The Welch-Berlekamp Algorithm for Correcting Errors in Data

DevFeed: [The Welch-Berlekamp Algorithm for Correcting Errors in Data](<https://devfeed.tech/articles/the-welch-berlekamp-algorithm-for-correcting-errors-in-data-40387.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2015/09/07/welch-berlekamp/>)

Published: 2015-09-07T11:02:00Z

Content type: tutorial

Language: en

Sources: [Jeremy Kun](<https://devfeed.tech/sources/jeremy-kun.md>)

Topics: [Algorithm](<https://devfeed.tech/topics/algorithm.md>), [Code](<https://devfeed.tech/topics/code.md>), [data](<https://devfeed.tech/topics/data.md>)

Tags: [berlekamp-welsh](<https://devfeed.tech/tags/berlekamp-welsh.md>), [code](<https://devfeed.tech/tags/code.md>), [error-correcting-codes](<https://devfeed.tech/tags/error-correcting-codes.md>), [error-correction](<https://devfeed.tech/tags/error-correction.md>), [finite-fields](<https://devfeed.tech/tags/finite-fields.md>), [graphics](<https://devfeed.tech/tags/graphics.md>), [image-analysis](<https://devfeed.tech/tags/image-analysis.md>), [mathematics](<https://devfeed.tech/tags/mathematics.md>), [polynomial-interpolation](<https://devfeed.tech/tags/polynomial-interpolation.md>), [polynomials](<https://devfeed.tech/tags/polynomials.md>), [programming](<https://devfeed.tech/tags/programming.md>), [python](<https://devfeed.tech/tags/python.md>), [reed-solomon-codes](<https://devfeed.tech/tags/reed-solomon-codes.md>), [resilience](<https://devfeed.tech/tags/resilience.md>)

### AI overview

This tutorial explains the intuition behind Reed-Solomon error-correcting codes and implements them using polynomial-based encoding. It describes how adding redundant points can provide resilience to corrupted data while limiting the extra information required.

### Source excerpt

In this post we'll implement Reed-Solomon error-correcting codes and use them to play with codes. In our last post we defined Reed-Solomon codes rigorously, but in this post we'll focus on intuition and code. As usual the code and data used in this post is available on this blog's Github page. The main intuition behind Reed-Solomon codes (and basically all the historically major codes) is Error correction is about adding redundancy, and polynomials are a really efficient way to do that.

## Learning a single-variable polynomial, or the power of adaptive queries

DevFeed: [Learning a single-variable polynomial, or the power of adaptive queries](<https://devfeed.tech/articles/learning-a-single-variable-polynomial-or-the-power-of-adaptive-queries-40370.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2014/11/18/learning-a-single-variable-polynomial-or-the-power-of-adaptive-queries/>)

Published: 2014-11-18T09:00:18Z

Content type: tutorial

Language: en

Sources: [Jeremy Kun](<https://devfeed.tech/sources/jeremy-kun.md>)

Topics: [Computing](<https://devfeed.tech/topics/computing.md>), [Algorithm](<https://devfeed.tech/topics/algorithm.md>), [Query (disambiguation)](<https://devfeed.tech/topics/query.md>)

Tags: [adaptive-queries](<https://devfeed.tech/tags/adaptive-queries.md>), [algorithm](<https://devfeed.tech/tags/algorithm.md>), [github](<https://devfeed.tech/tags/github.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [learning-theory](<https://devfeed.tech/tags/learning-theory.md>), [number-theory](<https://devfeed.tech/tags/number-theory.md>), [polynomial-identity-testing](<https://devfeed.tech/tags/polynomial-identity-testing.md>), [polynomial-interpolation](<https://devfeed.tech/tags/polynomial-interpolation.md>), [polynomials](<https://devfeed.tech/tags/polynomials.md>)

### AI overview

This tutorial shows how adaptive queries can recover a secret single-variable polynomial with nonnegative integer coefficients using only two queries: p(1) and p(p(1)+1). It explains how modular arithmetic extracts the coefficients and contrasts this with the larger number of non-adaptive queries required by polynomial interpolation.

### Source excerpt

Problem: Alice chooses a secret polynomial $ p(x)$ with nonnegative integer coefficients. Bob wants to discover this polynomial by querying Alice for the value of $ p(x)$ for some integer $ x$ of Bob's choice. What is the minimal number of queries Bob needs to determine $ p(x)$ exactly? Solution: Two queries. The first is $ p(1)$, and if we call $ N = p(1) + 1$, then the second query is $ p(N)$.

## Bezier Curves and Picasso

DevFeed: [Bezier Curves and Picasso](<https://devfeed.tech/articles/bezier-curves-and-picasso-40317.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2013/05/11/bezier-curves-and-picasso/>)

Published: 2013-05-11T00:32:05Z

Content type: tutorial

Language: en

Sources: [Jeremy Kun](<https://devfeed.tech/sources/jeremy-kun.md>)

Topics: [math](<https://devfeed.tech/topics/math.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>), [Picasso](<https://devfeed.tech/topics/picasso.md>), [JavaScript](<https://devfeed.tech/topics/javascript.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [art](<https://devfeed.tech/tags/art.md>), [bezier-curves](<https://devfeed.tech/tags/bezier-curves.md>), [de-casteljau](<https://devfeed.tech/tags/de-casteljau.md>), [graphics](<https://devfeed.tech/tags/graphics.md>), [interactive](<https://devfeed.tech/tags/interactive.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [math](<https://devfeed.tech/tags/math.md>), [painting](<https://devfeed.tech/tags/painting.md>), [picasso](<https://devfeed.tech/tags/picasso.md>), [polynomials](<https://devfeed.tech/tags/polynomials.md>), [programming](<https://devfeed.tech/tags/programming.md>), [svg](<https://devfeed.tech/tags/svg.md>)

### AI overview

This tutorial explains Bezier curves through the mathematical ideas behind parameterized curves, then presents a simple algorithm and JavaScript implementation for drawing them. It applies the method to recreate one of Pablo Picasso's line drawings as a sequence of Bezier curves.

### Source excerpt

Pablo Picasso Simplicity and the Artist Some of my favorite of Pablo Picasso's works are his line drawings. He did a number of them about animals: an owl, a camel, a butterfly, etc. This piece called "Dog" is on my wall: Dachshund-Picasso-Sketch (Jump to interactive demo where we recreate "Dog" using the math in this post) These paintings are extremely simple but somehow strike the viewer as deeply profound. They give the impression of being quite simple to design and draw.

## Fundamental Theorem of Algebra (With Picard's Little Theorem)

DevFeed: [Fundamental Theorem of Algebra (With Picard's Little Theorem)](<https://devfeed.tech/articles/fundamental-theorem-of-algebra-with-picard-s-little-theorem-40261.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2012/02/07/fundamental-theorem-of-algebra-with-picards-little-theorem/>)

Published: 2012-02-07T21:30:12Z

Content type: tutorial

Language: en

Sources: [Jeremy Kun](<https://devfeed.tech/sources/jeremy-kun.md>)

Topics: [Math and Logic](<https://devfeed.tech/topics/math-and-logic.md>), [Mathematics](<https://devfeed.tech/topics/mathematics.md>)

Tags: [complex-analysis](<https://devfeed.tech/tags/complex-analysis.md>), [fundamental-theorem-of-algebra](<https://devfeed.tech/tags/fundamental-theorem-of-algebra.md>), [mathematics](<https://devfeed.tech/tags/mathematics.md>), [polynomials](<https://devfeed.tech/tags/polynomials.md>)

### AI overview

This post proves the Fundamental Theorem of Algebra using Picard's Little Theorem. Assuming basic complex analysis, it argues that a nonconstant polynomial cannot omit both zero and a suitable reciprocal value, because continuity and boundedness would force a zero.

### Source excerpt

This post assumes familiarity with some basic concepts in complex analysis, including continuity and entire (everywhere complex-differentiable) functions. This is likely the simplest proof of the theorem (at least, among those that this author has seen), although it stands on the shoulders of a highly nontrivial theorem. The fundamental theorem of algebra has quite a few number of proofs (enough to fill a book!). In fact, it seems a new tool in mathematics can prove its worth by being able to prove the fundamental theorem in a different way.

## The Fundamental Theorem of Algebra (with Galois Theory)

DevFeed: [The Fundamental Theorem of Algebra (with Galois Theory)](<https://devfeed.tech/articles/the-fundamental-theorem-of-algebra-with-galois-theory-40259.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2012/02/02/the-fundamental-theorem-of-algebra-galois-theory/>)

Published: 2012-02-02T22:42:11Z

Content type: article

Language: en

Sources: [Jeremy Kun](<https://devfeed.tech/sources/jeremy-kun.md>)

Topics: [Mathematics](<https://devfeed.tech/topics/mathematics.md>), [Math and Logic](<https://devfeed.tech/topics/math-and-logic.md>)

Tags: [field](<https://devfeed.tech/tags/field.md>), [fundamental-theorem-of-algebra](<https://devfeed.tech/tags/fundamental-theorem-of-algebra.md>), [galois-theory](<https://devfeed.tech/tags/galois-theory.md>), [group-theory](<https://devfeed.tech/tags/group-theory.md>), [mathematics](<https://devfeed.tech/tags/mathematics.md>), [polynomials](<https://devfeed.tech/tags/polynomials.md>), [roots](<https://devfeed.tech/tags/roots.md>)

### AI overview

This mathematics post presents a Galois-theoretic proof strategy for the fundamental theorem of algebra. It assumes familiarity with field extensions, Galois theory, and group theory, and develops the argument using splitting fields, an intermediate extension of degree 2, Sylow subgroups, and the Galois correspondence.

### Source excerpt

This post assumes familiarity with some basic concepts in abstract algebra, specifically the terminology of field extensions, and the classical results in Galois theory and group theory. The fundamental theorem of algebra has quite a few number of proofs (enough to fill a book!). In fact, it seems a new tool in mathematics can prove its worth by being able to prove the fundamental theorem in a different way. This series of proofs of the fundamental theorem also highlights how in mathematics there are many many ways to prove a single theorem, and in re-proving an established theorem we introduce new concepts and strategies.

## Sums of k Powers

DevFeed: [Sums of k Powers](<https://devfeed.tech/articles/sums-of-k-powers-40216.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2011/07/01/sums-of-k-powers/>)

Published: 2011-07-01T12:52:29Z

Content type: article

Language: en

Sources: [Jeremy Kun](<https://devfeed.tech/sources/jeremy-kun.md>)

Topics: [polynomials](<https://devfeed.tech/topics/polynomials.md>), [context](<https://devfeed.tech/topics/context.md>)

Tags: [complex-numbers](<https://devfeed.tech/tags/complex-numbers.md>), [factoring](<https://devfeed.tech/tags/factoring.md>), [finite-fields](<https://devfeed.tech/tags/finite-fields.md>), [induction](<https://devfeed.tech/tags/induction.md>), [polynomial-ring](<https://devfeed.tech/tags/polynomial-ring.md>), [polynomials](<https://devfeed.tech/tags/polynomials.md>)

### AI overview

The article proves the geometric-series identity for sums of powers using base-k notation, polynomial factorization, and mathematical induction. It also explains extensions of the identity to fields such as the complex numbers and finite fields.

### Source excerpt

Problem: Prove that for all $ n,k \in \mathbb{N}, k > 1$, we have $$\sum \limits_{i=0}^{n} k^i = \frac{k^{n+1}-1}{k-1}$$ Solution: Representing the numbers in base $ k$, we have that each term of the sum is all 0's except for a 1 in the $ i$th place. Hence, the sum of all terms is the $ n$-digit number comprised of all 1's. Multiplying by $ k-1$ gives us the $ n$-digit number where every digit is $ k-1$.