Finding a bug in Dummit and Foote's Abstract Algebra
Posted by evakhoury 4 days ago
Comments
Comment by generationP 1 day ago
Comment by ndriscoll 1 day ago
Comment by Paracompact 1 day ago
After years of using the things, I believe not enough focus is given to high-velocity uses of proof assistants for prototyping. They can altogether replace scratch paper for fumbling around with new concepts.
Comment by dnautics 1 day ago
https://github.com/ityonemo/bpa
Its painfully verbose and explicit but its designed to let you cut down to the structure of the proof with a query language
Comment by IngoBlechschmid 15 hours ago
Comment by troethe 1 day ago
I think a more elegant solution would be to soften the definition of a left inverse from a function `g: B -> A` to a function `g: f(A) -> A` where `f(A)` is the subset of elements in `B`, that actually get mapped to by `f` or in the words of the book's function definition, the set of "right" elements in `f`.
This solves the edge-case too, as `f(A) = f({}) = {}` and there exists (exactly one) function `g: {} -> {}`, which also trivially is a left inverse of `f`.
The real problem here was, that the statement `g: B -> A` needlessly required `g` to map back elements in B to A, that couldn't even be produced by `f` and should therefore be irrelevant for a left inverse.
Comment by ndriscoll 1 day ago
You could of course interpret some of these basic theorems as saying "well I'd might as well take my function to be surjective since the 'meat' is that case." Much like you could just take all functions to be injective by modding out the kernel since that's the real "meat." And indeed one might interpret the first isomorphism theorem as saying exactly those two things: the isomorphism A/ker f = im f is "the real substance of the map f."
Comment by troethe 1 day ago
Comment by ndriscoll 1 day ago
The basic result here is every function factors as a surjection (collapsing to the quotient) followed by an isomorphism (with the image) followed by an injection (enlarging the codomain). The surjection and injection are "trivial" and the isomorphism is the part that "does something" (permuting your thing somehow).
Comment by troethe 1 day ago
`g` and `f` aren't functions in a programming language and `A` and `B` are not types. There is nothing like a type checker forbidding you from composing `f: A -> B` and `g: f(A) -> A`.
Comment by ndriscoll 1 day ago
And for e.g. for vector spaces or modules over semisimple rings they're actually the same so there's a real statement being made to say they're not always.
Comment by troethe 1 day ago
But we will only ever get a real answer to this question, when the original poster finishes formalizing the whole book and can tell us which weakenings break further proofs in the books and which won't.
Comment by ajkjk 1 day ago
This is kinda nice also because it means that for e.g. the function (a,b) -> (1, 2) given by f(a) = 1, f(b) = 1, you don't need its left inverse to specify that g(2) = a or b, but instead you can have g(2) = {} which doesn't require making any non-canonical choices.
(I'm too sleepy atm to think through this in detail. I might regret this proposal after a nap)
Comment by troethe 1 day ago
What are you referring to here in particular?
I think the property of `g` to be a well defined function is a lot more important than for its domain to be `B`, when `f(A)` is enough to make the composition well defined.
Comment by ndriscoll 1 day ago
Most algebra books I've read are either explicitly or at least implicitly setting up structural analogies to introduce categories, where your A and B are indeed fixed/"typed".
Comment by ajkjk 1 day ago
But, I disagree. partial functions B->A are just a superset of functions B->A, so requiring g to be partial is just relaxing a requirement. Whereas requiring g: im(A)->A adds an additional restriction, potentially breaking any place that concept of a left inverse is used. Invariably someone will just define a new thing equivalent to what is normally called the left inverse because they still need the concept for some reason.
Comment by jonlong 1 day ago
The subtlety is now that left-cancellativity is not equivalent to having a left inverse, for exactly the reason pointed out.
The value of this observation is that left-cancellativity is a useful generalization of injectivity that works in any category, where left-cancellative morphisms are called monomorphisms. If you already know about monomorphisms, it's easier to notice that there's something "off" about D&F's exercise!
Comment by hyperhello 1 day ago
Comment by BeetleB 1 day ago
I believe it doesn't make any difference to any meaningful result. It merely makes it easier to write theorems without specifying exceptions.
Comment by gpm 1 day ago
It's also the definitions the book supplies though (and the standard ones). Mathematics works over definitions. Everyone is free to do math over whatever definitions they want - but what is or isn't true follows from them. Lots of definitions and theorems exclude things like empty-set cases because they're weird, but that has to be explicit (otherwise someone will apply a theorem to the empty set and it will lead them to incorrect conclusions).
Comment by ndriscoll 1 day ago
The point is you either send an element of the codomain to its (unique by injectivity) preimage if it's in the image, or to an arbitrary element of A if it's not, and that's a left inverse. But then if B has an element, A needs one for you to pick your arbitrary target.
In a sense, your claim that the problem is a smaller domain than codomain does contribute though; if f is also surjective, then this case can't happen, so bijective iff invertible (the empty function is vacuously bijective and its own inverse).
Comment by gpm 1 day ago
Comment by tim-kt 1 day ago
In other words, the statement "for every x in {} it holds that <anything>" is always true.
Comment by layer8 1 day ago
Comment by tim-kt 1 day ago
Comment by mitxela 1 day ago
Comment by shmoil 1 day ago
LOL
Comment by mitxela 1 day ago
Comment by voxl 1 day ago
Comment by 9864325789976 18 hours ago
Comment by psYchotic 1 day ago
The first criterion for a function is stated as:
> The first item in each pair comes from A.
The counter-evidence for the proposition says:
> Let A = {}, and B = {1}. Let f: A -> B = {}
How does this f satisfy the first criterion, if A is uninhabited? It feels like this function can't be invoked. Am I thinking too much in terms of types here?
Comment by changoplatanero 1 day ago
Comment by psYchotic 1 day ago
I was trying to come up with something to explain why I couldn't see it myself: every element of an empty set of integers is both even and odd. This feels counterintuitive to me, until I flip it around into a question: what is the set of all integers that are both even and odd?
Comment by zero-sharp 1 day ago
The post proposes a counterexample of a function with a empty domain A. Some authors do actually specify that the domain should be nonempty in this theorem. This is a common result. Others authors don't. It's not a huge deal.