Видео

Thank you for making the video! For ring, the multiplication does not form a monoid, because it does not need to have the identity. The unital ring needs to have the identity.

There's some nuance on the double turnstyle (semantic entailment, |=), this A |= B says that *in every model* in which the statement A *evaluates to true*, B also *evaluates to true*. This point was not expressed very clearly in the video (although, words are said to the effect in the video, I don't think it's given due attention or clarity). The issue is with the 'in every model' part, because we need to be clear exactly what a model is; A model is something which associates *statements* in the language with truth values, via rules based on how the model associates *names* in the language with objects, and operators with mappings (discussed further down). Notice, we completely forgot to discuss objects in this video. We only consider something to be a model that has relevant semantics if it corresponds to the formal logic system that we are writing proofs in, which means for each operator in the language which is involved in the inference rules there is a 'fixed interpretation' across all these models, and there are 3 kinds of operator (with different arities- number of arguments): - connective: a symbol that joins *statements* in the language, a mapping from truth values to truth values, which is given by a 'truth table' in the model - relation/predicate: a symbol that joins *terms* in the language, a mapping from a list of *objects* in the model to a truth value in the model - function: a symbol that creates new *terms* in the language, a mapping from a list of *objects* in the model to another *object* in the model For each of these, there are those with fixed interpretations (depending on the exact specifics of the logic system): - connectives: NOT, AND, OR, XOR, IMPL, RIMPL, NAND, NOR, XNOR, ... - relations/predicates: EQUALS, NOT EQUALS, ... - functions: IDENTITY, COMPOSITION, SELECTION, RECURSION, ... So here's where this gets interesting: In predicate logic, we can represent sets by their characteristic relation, also known as a unary predicate, the order of a predicate is based on what sorts of objects it can take as a parameter 0th order: logical propositions, basically names for individual truth values, these have to be nullary as they take no objects. 1st order: objects can be given by names, variables, or function symbols or any combination thereof 2nd order: objects can be the sets which correspond to 1st order predicates, and anything lower ... nth order: objects can be the sets which correspond to (n-1)th order predicates, and anything lower and infinite order: objects can be any nth order It can be shown that 2nd order is as expressive as infinite order, so we basically just have 3 kinds of predicate logic: propositional logic, first order logic (FOL), and predicate logic in general. Soundness is the property of a logic system that A |- B ensures A |= B whereas completeness is that A |= B ensures A |- B Godel actually showed that FOL is complete, not that it is incomplete (the opposite of this video's conclusion) With reference to a logical theory (a collection of statements) T, a 'provable' statement S is one which holds T |- S, whereas a 'valid' statement S is one which holds T |= S (true in every model of T). However, confusingly, Godel also showed that 'Q', called Robinson's arithmetic (which is weaker than Peano Arithmetic, as Q is finitely axiomatised whereas PA needs infinitely many axioms) is incomplete by a different notion of completeness, which refers to the provability of statements within a system, not whether valid statements correspond to provable statements at all. So there is both a Godel's Completeness theorem and a Godel's Incompleteness theorem. But they are actually related. I am not entirely sure about this point, anyone that has more information please let me know, but I think the following is accurate: Even though FOL is complete, predicate logic in general (i.e. 2nd order and up) is not complete, because proofs are 'countably' infinite (since each individual proof is finite) but second order theories concern 'uncountably' infinite objects that are acted upon within the language. Basically, provability first requires constructability (or 'effectivity' or 'decidability') and Godel's incompleteness is an example of a failure in constructability (via diagonal argument).

terrible video

literally all bullshit abstraction

Thx. I always got stuck when trying to link rotation to euler number. Finally i realized that it's rotated by 1+εi instead of i itself

This is undoubtedly the best introduction to Type Theory on RUclips. My compliments! ❤

I think there is an error in the explanation: exponential functions were with the whole set/vector (i.e. ALL values!) of properties while the combination was multiplication. Which makes sense: if you have colours and fruits and merge it with colours of vegetables you will get the sum of the elements not the product. (given they have the same colours) The exponential operation from 10:00 on is the set of 2-tuples (pairs): - relations of colours from "a" with a full vector of properties of fruits - left hand side element - the relations of a colour from "a" with a full vector of properties of vegetables - right hand side ...equals the number of combinations of colours from "a" with the complete set of properties of fruits AND that of vegetables. The same goes on later with people and properties. I believe you want a triple (person, weight, height). Otherwise we would get the function of all properties and populations. I.e we'd have a mulitverse and each element would be the set of relations like (a strawberry is green AND and Orange is Yellow AND a leek is purple...) so its more like a mux/demux kind of thing

good work

Like with numbers, you can obtain a unit as the exponential of 0. (There is exactly one function to map from the empty type to a fixed arbitrary type). Unlike numbers, the base can also be 0.

Appreciate your content very much 🙏🏼

The opening note is overly simple. Types wouldn't make _all_ of software development easier. It prevents some bugs, but you still need proper mathematics on the business requirements, which **SURPRISE** isn't all written down in a master compendium that rivals Les Miserables.

Currying _is_ spicy, but it's named after a person.

I think i just don't get it. Like so what? What does it bring to the table? How does it corellate with the real world? I know about the sum types and currying (never used it or have seen somebody use it), but what about the stuff at the end, what's the real world example of that?

E.W. Dijkstra used the idea of treating a two argument function as a new function with a fixed first function as currying (somebody called Curry, I presume). So currying the two argument Add function with 1 would give you the Incr function, or with -1 to give you Decr.

wait but a pear is a fruit so how can it contain a fruit

I’ve been somwhat interested in abstract algebra (and beyond)’s connection to programming but I never quite managed to grasp it, but the stuff in this video just clicked. So thanks! In which video so hou further explain monoids? I had a tiny bit of group theory at University so I understood the basic defintion at Wikipedia fine, but I’d like to know more. EDIT: found a ‘what is a monoid’ video, I assume it’s that one

Planets are oblate spheroids - I don’t think any truly spherical planets exist in the universe. If there are any non-rotating neutron stars, they might be the closest thing to a literally spherical object that might exist. Non-rotating white dwarfs would also be pretty close to perfect sphericity. Minimal magnetic fields and being old and cold would get these hypothetical objects even closer to perfection. A star called KIC 11145123 (AKA Kepler 11145123) has been called the most spherical natural object ever measured..although, as a main-sequence star, it is less spherical than a slowly rotating neutron star. ..so..y’know… ..interesting stuff… ,{^_^}”

I dont get the difference between the unit type and the empty type in your description :/

Hope to see a video on the calculus of types as a followup!

Very nice videos for newbies! ❤❤

This is basically set theory. I never knew algebra of types existed! I'd like to understand where they start to look different

No, zero isn't a natural number.

Is there a meaningful distinction between currying and function composition? Or do they mean the same thing, just in different contexts?

Do note that type theory ignores real world scenarios like when a function only can return 2 out of 3 possible values. In the real world you have to keep the real world in mind, rather than only following what a theoretical world can do. Also, using those constraints you get from a real world scenario, you can often end up with better code, than if you forced yourself to handle impossible scenarios, or scenarios that shouldn't happen.

Sum types are also useful when making a parser: struct Token { enum { TOK_INTEGER, TOK_,FLOAT, TOK_IDENT, TOK_KEYWORD /* ... */ } kind; union { struct { uint64_t value, bool signed } _integer; double _float; char* _string; enum { KW_FUNCTION, KW_STRUCT, KW_ENUM, KW_UNION, KW_IMPORT /* ... */ } _keyword; }; };

15:00 The bottom two rules allows you to simplify programs: a pair of functions to the same codomain can be merged into one by getting the disjoint union of the two domains and doing some pattern matching internally. That allows you to have less functions at the tradeoff of their domain/codomains being more complicated. And a function that has a structured input can be changed to a chain of composed functions that process each field of the product type sequentially. That allows you to have more functions where each one can focus on just part of the original value.

7:20 An interesting aside is that the exponential 2^3=8 is for all *possible* functions of the `from Fruit to Bool` type. The example shown in the top is a specific function from that general type even though it's programming type signature would also be Fruit -> Bool. The general vs specific function distinction was confusing to me in the past.

2:10 Sugar, Spice, everything nice, armpit hair, snails, a puppy dog tail, and chemical X.

a

Is there a way to make a one time donation without subscribing? These videos are _excellent_.

Presupposition 1: Logical systems that rely on presuppositions are technically not "closed" and therefore not complete. Presupposition 2: All logical systems rely on presuppositions. Claim: Most logic systems are not complete 🫷 ❌ Rebuttal: Most logic systems are not built on imperceptible-selection-bias presuppositions. ☝✅

I love how concise and intelligible your videos about these somewhat obscure and mysterious subjects are. Looking foreward to the category theory one :)

I've actively been trying to understand these concepts for so long now, but after seeing this, it finally feels like it "clicked". Fantastic job!

this was super helpful. made a lot of sense

ahhh, the subject of my bachelor paper and (if all goes well) my master's thesis as well ❤❤ great to see you do a video on type theory!!

Love this video!!!

1:42 Cartesian* :P

i wonder if we will wonder in the proof assistant world with that

Yesh! Great polynomial intro into type math! 🎷🎻 Also add in one of future videos that an empty type is useful as: - a marker of a place in the code which shouldn’t be reachable, or a function that doesn’t return; - an empty error additive means no error can ever happen, if we write generic code that’s agnostic about specific error types and wish to use it with error-less functions; - a quirk to type only empty data structures: List<0> can contain just an empty list. Likewise 1 is useful in generic data structures to add no other information where some could’ve been provided and (ideally) occupy 0 extra bytes of memory. No wonder that “trivial values” get extremely useful in generic context, as it’s the case in math overall and why they were devised, more or less, historically (but more so now when we know better why we want them to exist!).

5:15 "please note that this is very different from returning a pair, which would always contain a number *and* an error" If only someone had shown this to the inventors of the Go language

I never knew you could do algebra with types. This is amazing!

Lesssgoooo a type theory video!🎉

If we can choose axioms freely, they cease to be proper axioms (ie. self-evident truths) and become ex falso arguments leading to the logical Explosion.

This doesn't mean much since you can expand the set of axioms that constitute a system, that creates more holes but less holes overall compared to the new syntactic rules you can create, so the "holes" will be less common within the system, as it is more and more complete. Even though absolute completeness is likely impossible. But even then, we can always rely on physics like meta mathematical reasoning (reasoning about the system itself) to know these statements are true, but we would only be unable to prove it is true.

I totally disagree that sqrt of ab not equal to sqrt of "a" times sqrt of "b". That's because you are not considering the phase shifts. There are RUclips videos showing that. Check them out.

2:38: Any group can be represented by permutation matrices. This statement is only valid for finite groups (see Cayleys theorem) and compact groups (Peter-Weyl Theorem).

neat

This is so wonderful!!

I have somewhat a fear of mathematics and cannot for sure tell you what 1001*10 is within 30 seconds on pressure, but everything in here was put so perfectly clear, simple and the and visualisations are superb! RUclips algorithm as well as people like you will save humanity.

You should have followed with an example on a completeness statement that isn't syntactically true. It would help to reinforce the implications of the entire video.