Ali Khudiyev

Live Aquarium

Mon, 16 Mar 2026 14:37:00 +0000

FishLive – Live Aquarium

Set Theory

Sun, 07 Dec 2025 19:00:00 +0000

Lemmas & Theorems

Lemma 1 (Zorn’s lemma). If $X$ is a partially ordered set such that every chain in $X$ has an upper bound, then $X$ contains a maximal element.

Theorem 1 (Recursion). If $a$ is an element of a set $X$, and if $f$ is a function from $X$ to $X$, then there exists a function $u$ from $w$ to $X$ such that $u(0) = a$ and such that $u(n^+) = f(u(n))$ for all $n$ in $w$.

Theorem 2 (Well ordering). Every set can be well ordered.

Theorem 3 (Transfinite recursion). If $W$ is a well ordered set, and if $f$ is a sequence function of type $W$ in a set $X$, then there exists a unique function $U$ from $W$ into $X$ such that $U(a) = f(U^a)$ for each $a$ in $W$.

Theorem 4 (Counting). Each well ordered set is similar to a unique ordinal number.

Theorem 5 (Schröder-Bernstein theorem). If $X \precsim Y$ and $Y \precsim Z$, then $X \sim Y$.

Theorem 6. Every set is strictly dominated by its power set, or, in other words,
\[X \prec \mathcal{P}(X)\]
for all $X$.

Set Theory

Sun, 07 Dec 2025 19:00:00 +0000

Axioms

Axiom 1 (Axiom of Extension). Two sets are equal if and only if they have the same elements.

Axiom 2 (Axiom of Specification). To every set $A$ and to every condition $S(x)$ there corresponds a set $B$ whose elements are exactly those elements $x$ of $A$ for which $S(x)$ holds.

Axiom 3 (Axiom of Pairing). For any two sets there exists a set that they both belong to.

Axiom 4 (Axiom of Unions). For every collection of sets there exists a set that contains all the elements that belong to at least one set of the given collection.

Axiom 5 (Axiom of Powers). For each set there exists a collection of sets that contains among its elements all the subsets of the given set.

Axiom 6 (Axiom of Infinity). There exists a set containing 0 and containing the successor of each of its elements.

Axiom 7 (Axiom of Choice). The Cartesian product of a non-empty family of non-empty sets is non-empty.

Axiom 8 (Axiom of Substitution). If $S(a, b)$ is a sentence such that for each $a$ in a set $A$ the set ${b : S(a, b)}$ can be formed, then there exists a function $F$ with domain $A$ such that $F(a) = {b : S(a, b)}$ for each $a$ in $A$.

Set Theory

Sun, 07 Dec 2025 19:00:00 +0000

Basics

Definition 1 (Set). Set is a bucket that can hold objects or elements.

Example:

\[\begin{aligned} &S = \{1, 2, 3, 4, 5\} \quad\text{(S is a set of some numbers)} \\ &C = \{a, b, g, r, s\} \quad\text{(C is a set of some letters)} \end{aligned}\]

Remark 1 (Set Membership). Given a set $S$ and an element $x$, $x$ can either be included in $S$ (denoted as $x \in S$), or excluded in $S$ (denoted as $x \not\in S$).

Example:

\[\begin{aligned} &3 \in S, \text{but}\ 8 \not\in S \\ &B \not\in C, \text{but}\ b \in S \end{aligned}\]

Remark 2 (Set Construction). A set builder notation ${x : \text{}\}$ can be used to construct sets more conveniently.

Example:

\[\begin{aligned} &N = \{x : x \in \mathbb{Z} \text{ and } 0 < x < 101\} \quad\text{$N$ is a set of all positive integers up to 101}\\ &E = \{x : x \in \mathbb{N} \text{ and } x \mod 2 = 0\} \quad\text{$E$ is a set of all even natural numbers}\\ \end{aligned}\]

Definition 2 (Union of Sets). Union of sets $A = {a_1, a_2, \cdots}$ and $B = {b_1, b_2, \cdots}$ is another set containing all the elements of $A$ and $B$, i.e., $A \cup B = {a_1, a_2, a_3, \cdots, b_1, b_2, \cdots}$.

Example:

\[\begin{aligned} S \cup C = \{1, 2, 3, 4, 5, a, b, g, r, s\} \end{aligned}\]

Definition 3 (Intersection of Sets). Intersection of sets $A$ and $B$ is another set containing all the common elements that appear both in $A$ and $B$, i.e., $A \cap B =$

Example:

\[\begin{aligned} S \cap C = \{\} \end{aligned}\]

More About Sets

Definition 4 (Countability). A set $X$ is called countable (or denumerable) in case $X \precsim w$ and countably infinite in case $X \sim w$.

Definition 5. If $X$ and $Y$ are sets such that $X$ is equivalent to a subset of $Y$, we say $Y$ dominates $X$ or $X \precsim Y$

Remark 3. Strong domination vs weak domination

PhD Defended

Fri, 28 Nov 2025 11:00:00 +0000

Today I defended my PhD thesis in front of four French jury members in Strasbourg. My presentation took $\sim$45 minutes, and then the back-and-forth Q&A with the jury members took $\sim$60 minutes. Examiners and other jury members asked good and relevant questions, some of which were very on point. I felt like they were genuinely interested in my research work and what I was about to say to answer their questions. I was very happy when I observed this from the beginning of the Q&A part. They also seemed to like my responses and, I guess, my way of thinking through problems, which was good to hear, too. We seemed to disagree on a couple of things with one jury member, but we both acknowledged that either of us could be wrong. I didn’t know what to expect when I started my presentation, but then I felt like the work and everything else were appreciated by the jury. At the end of the defense, they discussed internally whether or not I deserve to get a PhD and then decided to declare me a PhD holder. I felt like the process went very smoothly and very well in general. I got my PhD degree in AI. People cheered, I received some nice gifts, then I left the lab to digest the things a little bit and have some fun with some of my fellow PhD students in Strasbourg.

Me in my PhD defense. 28.11.2025

At the final moments of the jury’s congratulations and others’ cheerings for me for getting a PhD, something struck me lightly. I internally had this very weird feeling about things. The whole thing seemed unreal because many fragments from the past 3 years of my PhD were playing in front of my eyes, and I couldn’t believe how, after this many years of “struggle”, without anyone truly rooting for you, except very few people, could end like this… people saying the nicest things and congratulating you for what you have done silently for the past 3 years. One of the people who supported me during this process was my director, Anne Jeannin-Girardon. My mother’s support meant a lot, too. I am thankful for this.

It is not really about having a PhD degree or becoming a doctor… Well, the world has made it this way, but keep an open mind, folks! We are who we are when there is no one in the audience watching us.

Cool C Tricks

Thu, 20 Nov 2025 11:41:00 +0000

1. Array initiliazation

int arr[] = { 0, 1, [10]=3, 100, -1, [4]=4, 2};
printf("%zu", sizeof(arr)/sizeof(int)); // 13 ints

2. Struct initiliazation

struct vertex {
    int i;
    enum {
        struct {
            uint8_t r;
            uint8_t g;
            uint8_t b;
        } data;
        uint8_t rgb[3];
    } color;
};

struct vertex p = { 
    .i=1, 
    .color = { 
        .data = { .r=255, .g=100, .b=40 }
    }
};

printf("%u %u %u", 
    p.color.rgb[0], 
    p.color.rgb[1], 
    p.color.rgb[2]
); // 255 100 40

3. Flexible array member

struct vec {
    size_t len;
    int data[];
};

struct vec *vec_alloc(size_t n){
    struct vec *v = malloc(
        sizeof(struct vec) + n * sizeof(int)
    );
    if(v) v->len = n;
    return v;
}

4. Type punning union

union fbits {
    float f;
    uint32_t u;
};

union fbits fb = { .f = 3.14 };
printf("%u", fb.u);

5. Macro for container address

#define container_of(ptr, type, member) \
    ((type*)((char*)ptr - offsetof(type, member)))

struct pck { char name; float val; int elems; };
struct pck p = { ... };
struct pck *ptr_p = container_of(&p.val, struct pack, val);

6. On-the-fly lambda

int age = ({
    int born_in = 1999;
    2025 - born_in;	// last line is returned
});

printf("%d", age); // 26

#define lambda(ret_type, func_body) \
    ({ ret_type __func func_body; __func; })

int (*get_age)(int) = lambda(
    int, (int born_in){
        return 2025 - born_in; 
    }
);

get_age(1999);	// 26

7. Generic programming (C11)

#define print(x) _Generic((x), \
    int: printf("%d", x), \
    float: printf("%f", x), \
    double: printf("%lf", x), \
    char: printf("%c", x), \
)

8. Good goto practice :)

void *jump_table[] = { &&LBL_1, &&LBL_2, &&LBL_3 };
goto *jump_table[1];

LBL_1:
printf("lbl_1\n");	// will NOT print
LBL_2:
printf("lbl_2\n");	// will print
LBL_3:
printf("lbl_3\n");	// will print

9. Cursed memory access

int i = 3;
float pi = 3.14;

int pi_without_p = *(int*)((char*)&pi - sizeof(int));
&i; // optional: add this to tell compiler to put the damn variables in the stack

10. Memory alignment in struct

struct __attribute__((packed)) packed {
    int8_t vals[8];
    char c;
};

struct __attribute__((aligned(32))) aligned {
    int8_t vals[8];
    char c;
};

printf("%zu %zu", 
    sizeof(struct packed),	// 33
    sizeof(struct aligned)	// 64
);

11. Fast table/list generation

#define LIST 			\
    X(RED, "red") 		\
    X(GREEN, "green")	\
    X(BLUE, "blue")		\

#define X(name, str) name,
enum Color { LIST };
#undef X

#define X(name, str) str,
const char *color_names[] = { LIST };
#undef X

12. Duff's device

register short *to, *from;
register count;
{
    register n = (count + 7) / 8;
    switch(count % 8){
        case 0: do { *to = *from++;
        case 7: 	 *to = *from++;
        case 6: 	 *to = *from++;
        case 5: 	 *to = *from++;
        case 4: 	 *to = *from++;
        case 3: 	 *to = *from++;
        case 2: 	 *to = *from++;
        case 1: 	 *to = *from++;
                } while (--n > 0);
    }
}

13. Implementation hiding

typedef struct vec* vec_t;

static inline vec_t *vec_alloc(size_t n){
    vec_t { size_t len; int data[]; } *v = NULL;
    v = malloc(sizeof(vec_t) + n * sizeof(int));
    if(v) v->len = n;
    return v;
}

14. Double-pointer cast trick

#define READ_ONCE(x) (*(volatile typeof(x)*)&(x))
#define WRITE_ONCE(x, val) (*(typeof(x)*)&(x) = (val))

// forces the compiler to actually read/write memory every time
// (bypass optimizer removing "redundant" loads/stores)

15. Inline assembly


static inline uint32_t fast_div10(uint32_t n) {
    uint32_t q;
    asm volatile (
    "movl $0xcccccccd, %%ecx\n"	        // magic number
        "mull %%ecx\n"			// EDX:EAX = EAX * 0xCCCCCCCD
        "shrl $3, %%edx\n"		// q = EDX >> 3
        : "=d" (q)			// output: EDX → q
        : "a" (n)			// input:  EAX ← n
        : "cc"				// clobbers flags
    );
    return q;
}

16. Wicked arrays

int arr[] = { 1, 2, 3 };
int *ptr = arr + 1;

printf("%d, %d, %d", ptr[-1], arr[1], 2[arr]); 
// prints 1, 2, 3

17. Raw pointer wizardry

/* 
| func is a 2D array of functions (pointers) that 
| take a float number as an input and 
| return 2D array of functions (pointers), which 
| | take a float as their input and 
| | return a function (pointer) 
| | | taking an int as an input and 
| | | returning int*
*/
int *(*(*func[2][5])(float))(int *(*(*[2][5])(float))(int));

// ptr_func is the pointer holding the address of func
int *(*(*(*ptr_func)[2][5])(float))(int *(*(*[2][5])(float))(int)) = &func;

Mazes

Mon, 17 Nov 2025 10:00:00 +0000

Dynamic Harmony

Mon, 17 Nov 2025 10:00:00 +0000

Survival of the Scalable

Mon, 10 Nov 2025 21:28:00 +0000

Scaling AI won’t work, but Scalable AI will.

What do I mean by this? Well, you can’t keep pouring human labor to scale AI systems manually whenever there is a new challenge that is even more complex than what was represented by the previous training set used to train the network. In this sense, we shouldn’t bet on scaling AI by ourselves as a lasting strategy for true intelligence, also known as AGI.

In the game of evolution, the fittest is the survivor. In the evolution of AI, I suspect, the fittest is the scalable. Scalable doesn’t need (manual) scaling (by humans), because it scales autnomously, by itself.

To determine whether your architecture/algorithm is scalable or it needs (manual) scaling, you should ask this question to find out the answer: What would the scaled up version of any instantiation of my architecture/algorithm look like and is the transitioning to that bigger version encoded within the architecture/algorithm? If the transitioning to arbitrarily different scales is not encoded within your framework, then it’ll require manual work to solve more computationally complex tasks at some point in the future, almost surely.

In my opinion, you don’t have to invent the most advanced AI system, so advanced that no one can figure out how it could even possibly scale. Instead, you should probably aim for the most dumb systems that can scale very easily in a thousand different ways. Simplicity in architecture design may have a downside of not being able to address many cognitive challenges simultaneously, however, it has an advantage over a complicated architecture in flexibility and (efficient large-scale) operability.

Simplicity requires making assumptions and having assumptions usually implies compression. This is usually true because each new assumption/rule carries a potential to be combined with other assumptions/rules, giving us more implied facts. Since these new set of facts do not need to be stored explicityly (because they are implied already, and therefore, they could be derived by using the assumptions/rules at any moment), we save up memory by not storing these new facts explicityly; they are rather stored implictly by the means of computational consequences of the (physically) stored assumptions/rules.

Ali Khudiyev

Live Aquarium

Set Theory

Lemmas & Theorems

Set Theory

Axioms

Set Theory

Basics

More About Sets

PhD Defended

Cool C Tricks

Mazes

Dynamic Harmony

Survival of the Scalable

Broktor

Broke Doctor

Paper Submission

Academia

Thesis-Minded

But, Professor...

Seminars