# Algebra,

Published articles for Algebra,.

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

## Plan for Clojure AI, ML, and high-performance Uncomplicate ecosystem in 2026

DevFeed: [Plan for Clojure AI, ML, and high-performance Uncomplicate ecosystem in 2026](<https://devfeed.tech/articles/plan-for-clojure-ai-ml-and-high-performance-uncomplicate-ecosystem-in-2026-20726.md>)

Original publisher: [Read original article](<http://dragan.rocks/articles/25/Clojure-AI-ML-high-performance-Uncomplicate>)

Published: 2025-11-29T00:41:00Z

Content type: opinion

Language: en

Sources: [Dragan Djuric](<https://devfeed.tech/sources/dragan-djuric.md>)

Topics: [Clojure](<https://devfeed.tech/topics/clojure.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Machine learning](<https://devfeed.tech/topics/machine-learning.md>), [CUDA](<https://devfeed.tech/topics/cuda.md>), [OpenCL](<https://devfeed.tech/topics/opencl.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [NumPy](<https://devfeed.tech/topics/numpy.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-ml](<https://devfeed.tech/tags/ai-ml.md>), [algebra](<https://devfeed.tech/tags/algebra.md>), [apple](<https://devfeed.tech/tags/apple.md>), [clojure](<https://devfeed.tech/tags/clojure.md>), [cuda](<https://devfeed.tech/tags/cuda.md>), [linear](<https://devfeed.tech/tags/linear.md>), [matrices](<https://devfeed.tech/tags/matrices.md>), [neanderthal](<https://devfeed.tech/tags/neanderthal.md>), [opencl](<https://devfeed.tech/tags/opencl.md>), [programming](<https://devfeed.tech/tags/programming.md>), [vectors](<https://devfeed.tech/tags/vectors.md>)

### AI overview

The article outlines a 2026 development and funding plan for the Uncomplicate ecosystem of Clojure libraries for AI, machine learning, and high-performance computing. It describes support for Nvidia GPUs, Apple Silicon, CPUs, CUDA, OpenCL, and several planned library improvements.

### Source excerpt

I've applied for Clojurists Together yearly funding in 2026. Here's my application. If you are a Clojurists Together member, and would like to see continued development in this area, your vote can help me keep working on this :) My goal with this funding in 2026 is to continuously develop Clojure AI, ML, and high-performance ecosystem of Uncomplicate libraries (Neanderhal and many more), on Nvidia GPUs, Apple Silicon, and traditional PC. In this year, I will also focus on writing tutorals on my blog and creating websites for the projects involved, which is something that I wanted for years, but didn't have time to do because I spent all time on programming. How that work will benefit the Clojure community This will highly benefit the Clojure community as this is THE AI ecosystem for Clojure, and supporting AI is arguably the main focus on probably all software platforms. Clojure has something to offer on that front, beyond just calling OpenAI API as a web service! Uncomplicate grew to quite a few libraries (of which some are quite big; just Neanderthal is 28,000 lines of highly-condensed, aggresively macroized, and reusable code): Diamond ONNX Runtime, Neanderthal, Deep Diamond, ClojureCUDA, ClojureCPP, Apple Presets, ClojureCL, Fluokitten, Bayadera, Clojure Sound, and Commons. Here's a word or two of how I hope to improve each of these libraries with Clojurists Together funding in 2026. Neanderthal (Clojure's alternative to NumPy, on steroids) In 2025, Neanderthal celebrated its 10th birthday. It started as a humble but fast matrix and vector library for Clojure, but after 10 years of relentless improvements, now it boasts a general matrix/vector/linear algebra API implemented by no less than 5(!) engines for CPUs, GPU (Nvidia CUDA), GPU (OpenCL: AMD, Intel, Nvidia), Apple Silicon (Accelerate), and general CPU (OpenBLAS). And this is not a superficial support for the sake of ticking a check box; each of these engines support much more operations on exotic structure

## the algebra of dependent types

DevFeed: [the algebra of dependent types](<https://devfeed.tech/articles/the-algebra-of-dependent-types-36214.md>)

Original publisher: [Read original article](<https://dotat.at/@/2025-05-28-types.html>)

Published: 2025-05-29T00:07:51Z

Content type: article

Language: en

Sources: [Tony Finch's blog](<https://devfeed.tech/sources/tony-finch-s-blog.md>)

Topics: [Programming](<https://devfeed.tech/topics/programming.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [Standard ML](<https://devfeed.tech/topics/standard-ml.md>), [Rust](<https://devfeed.tech/topics/rust.md>)

Tags: [algebra](<https://devfeed.tech/tags/algebra.md>), [enum](<https://devfeed.tech/tags/enum.md>), [functional-programming](<https://devfeed.tech/tags/functional-programming.md>), [languages](<https://devfeed.tech/tags/languages.md>), [programming-languages](<https://devfeed.tech/tags/programming-languages.md>), [type-system](<https://devfeed.tech/tags/type-system.md>), [type-theory](<https://devfeed.tech/tags/type-theory.md>), [types](<https://devfeed.tech/tags/types.md>)

### AI overview

An explanation of why big-sigma and big-pi notation appears in dependent type theory. It connects dependent functions and dependent pairs to algebraic data types, showing how products correspond to multiplication and sum types to addition, with examples from type theory, Standard ML, Haskell, and Rust.

### Source excerpt

TIL (or this week-ish I learned) why big-sigma and big-pi turn up in the notation of dependent type theory. I've long been aware of the zoo of more obscure Greek letters that turn up in papers about type system features of functional programming languages, μ, Λ, Π, Σ. Their meaning is usually clear from context but the reason for the choice of notation is usually not explained. I recently stumbled on an explanation for Π (dependent functions) and Σ (dependent pairs) which turn out to be nicer than I expected, and closely related to every-day algebraic data types. sizes of types The easiest way to understand algebraic data types is by counting the inhabitants of a type. For example: the unit type () has one inhabitant, (), and the number 1 is why it's called the unit type; the bool type hass two inhabitants, false and true. I have even seen these types called 1 and 2 (cruelly, without explanation) in occasional papers. product types Or pairs or (more generally) tuples or records. Usually written, (A, B) The pair contains an A and a B, so the number of possible values is the number of possible A values multiplied by the number of possible B values. So it is spelled in type theory (and in Standard ML) like, A * B sum types Or disjoint union, or variant record. Declared in Haskell like, data Either a b = Left a | Right b Or in Rust like, enum Either<A, B> { Left(A), Right(B), } A value of the type is either an A or a B, so the number of possible values is the number of A values plus the number of B values. So it is spelled in type theory like, A + B dependent pairs In a dependent pair, the type of the second element depends on the value of the first. The classic example is a slice, roughly, struct IntSlice { len: usize, elem: &[i64; len], } (This might look a bit circular, but the idea is that an array [i64; N] must be told how big it is - its size is an explicit part of its type - but an IntSlice knows its own size. The traditional dependent "vector" type is a sized li

## Elliptic Curves as Elementary Equations

DevFeed: [Elliptic Curves as Elementary Equations](<https://devfeed.tech/articles/elliptic-curves-as-elementary-equations-40343.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2014/02/10/elliptic-curves-as-elementary-equations/>)

Published: 2014-02-10T10:00:40Z

Content type: tutorial

Language: en

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

Topics: [Mathematics](<https://devfeed.tech/topics/mathematics.md>), [Cryptography](<https://devfeed.tech/topics/cryptography.md>), [Security](<https://devfeed.tech/topics/security.md>)

Tags: [algebra](<https://devfeed.tech/tags/algebra.md>), [algebraic-geometry](<https://devfeed.tech/tags/algebraic-geometry.md>), [cryptography](<https://devfeed.tech/tags/cryptography.md>), [elliptic-curves](<https://devfeed.tech/tags/elliptic-curves.md>), [encryption](<https://devfeed.tech/tags/encryption.md>), [function](<https://devfeed.tech/tags/function.md>), [mathematica](<https://devfeed.tech/tags/mathematica.md>), [mathematics](<https://devfeed.tech/tags/mathematics.md>), [security](<https://devfeed.tech/tags/security.md>), [systems](<https://devfeed.tech/tags/systems.md>)

### AI overview

This introductory tutorial explains elliptic curves as the sets of solutions to cubic polynomial equations in two variables. It motivates their study through algebraic geometry and their role in encryption, then begins developing the elliptic curve group structure using an elementary example involving pyramids of spheres.

### Source excerpt

Finding solutions to systems of polynomial equations is one of the oldest and deepest problems in all of mathematics. This is broadly the domain of algebraic geometry, and mathematicians wield some of the most sophisticated and abstract tools available to attack these problems. The elliptic curve straddles the elementary and advanced mathematical worlds in an interesting way. On one hand, it's easy to describe in elementary terms: it's the set of solutions to a cubic function of two variables.

## Simulating a Fair Coin with a Biased Coin

DevFeed: [Simulating a Fair Coin with a Biased Coin](<https://devfeed.tech/articles/simulating-a-fair-coin-with-a-biased-coin-40342.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2014/02/08/simulating-a-fair-coin-with-a-biased-coin/>)

Published: 2014-02-08T19:03:46Z

Content type: tutorial

Language: en

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

Topics: [Computer science](<https://devfeed.tech/topics/computer-science.md>), [Mathematics](<https://devfeed.tech/topics/mathematics.md>), [Python](<https://devfeed.tech/topics/python.md>)

Tags: [algebra](<https://devfeed.tech/tags/algebra.md>), [coins](<https://devfeed.tech/tags/coins.md>), [guest-post](<https://devfeed.tech/tags/guest-post.md>), [mathematics](<https://devfeed.tech/tags/mathematics.md>), [probabilistic](<https://devfeed.tech/tags/probabilistic.md>), [python](<https://devfeed.tech/tags/python.md>), [random-number-generators](<https://devfeed.tech/tags/random-number-generators.md>), [science](<https://devfeed.tech/tags/science.md>)

### AI overview

This tutorial explains von Neumann's method for simulating a fair coin using a biased coin. It examines pairs of independent flips, discards matching pairs, returns the first result when the pair differs, and derives the expected number of flips.

### Source excerpt

This is a guest post by my friend and colleague Adam Lelkes. Adam's interests are in algebra and theoretical computer science. This gem came up because Adam gave a talk on probabilistic computation in which he discussed this technique. Problem: Simulate a fair coin given only access to a biased coin. Solution: (in Python) def fairCoin(biasedCoin): coin1, coin2 = 0,0 while coin1 == coin2: coin1, coin2 = biasedCoin(), biasedCoin() return coin1 Discussion: This is originally von Neumann's clever idea.

## Linear Algebra--A Primer

DevFeed: [Linear Algebra--A Primer](<https://devfeed.tech/articles/linear-algebra-a-primer-40204.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2011/06/19/linear-algebra-a-primer/>)

Published: 2011-06-19T18:39:40Z

Content type: tutorial

Language: en

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

Topics: [Mathematics](<https://devfeed.tech/topics/mathematics.md>), [Matrix](<https://devfeed.tech/topics/matrix-org.md>), [Graphs](<https://devfeed.tech/topics/graphs.md>)

Tags: [adjacency-matrix](<https://devfeed.tech/tags/adjacency-matrix.md>), [algebra](<https://devfeed.tech/tags/algebra.md>), [eigenvalues](<https://devfeed.tech/tags/eigenvalues.md>), [eigenvectors](<https://devfeed.tech/tags/eigenvectors.md>), [graph](<https://devfeed.tech/tags/graph.md>), [history](<https://devfeed.tech/tags/history.md>), [linear-algebra](<https://devfeed.tech/tags/linear-algebra.md>), [linear-independence](<https://devfeed.tech/tags/linear-independence.md>), [linear-maps](<https://devfeed.tech/tags/linear-maps.md>), [mathematics](<https://devfeed.tech/tags/mathematics.md>), [matrices](<https://devfeed.tech/tags/matrices.md>), [matrix](<https://devfeed.tech/tags/matrix.md>), [primer](<https://devfeed.tech/tags/primer.md>), [transformation](<https://devfeed.tech/tags/transformation.md>), [vector](<https://devfeed.tech/tags/vector.md>), [vector-spaces](<https://devfeed.tech/tags/vector-spaces.md>)

### AI overview

This primer introduces linear algebra through its historical origins in solving systems of linear equations. It explains determinants, matrices, vector algebra, and linear transformations, and shows how matrices can model graphs and compute path counts.

### Source excerpt

Story Time Linear algebra was founded around the same time as Calculus (think Leibniz, circa 1700) solely for the purpose of solving general systems of linear equations. The coefficients of a system were written in a grid form, with rows corresponding to equations and columns to the unknown variables. Using a computational tool called the determinant (an awkward, but computable formula involving only the coefficients of the equations in a system), researchers were able to solve these systems, opening a world of information about the positions of celestial bodies and large-scale measurements (of geodesic arcs) on the surface of the earth.