ellis-bell
Joined 6 years ago
Joined 6 years ago
quarks, the particles composing protons and neutrons, have fractional charge; these would be the particles that would interact with an electron or positron. the charges wouldn't work out (charge is conserved (as far as we known...)) so there wouldn't be a fundamental electromagnetic interaction between a single quark and a e+/e- (i.e., an annihilation). But there are fundamental weak interactions between quarks and e+/e-; these processes are known as inverse beta decay and are used for pet scans.
charge, baryon number, isospin and strangeness are all related by the Gell-Mann-Nishijima formula[1].
the overarching principle underlying this is that in quantum chromodynamics, the theory of the strong interaction, quarks are representations of an underlying SU(3) gauge group containing color charge (a quantum number) and electric charge quantized as -1/3e and +2/3e. QCD is a gauge theory (like all other theories of nature) and the gauge boson, the gluon, also pops out of demanding the theory be invariant under local SU(3) gauge transformations.
that said, no one has any clue why all of our physical theories are gauge theories :-)
https://en.wikipedia.org/wiki/Gell-Mann%E2%80%93Nishijima_fo...
The prerequisites are (self-reported) minimum, just calculus and mathematical maturity should be sufficient. I would check it out (it's free) and see if it's at an appropriate level.
Unfortunately I've yet to come across an introductory text or course on probability that is actually good :-(
that way you don't just meander idolly from day to day, but instead gain some intuition for the central problem (and of course have publishable work to appease the grant gods / the university).
trying to code up some of the work to experiment is also useful, but that can be a research problem of its own :-)
btw my understanding is that the heap came first in the logical development of C and other systems programming. so it made sense to have .text and other program data at the lowest virtual memory addresses and then have the heap grow towards higher memory addresses.
then when the stack became a thing it had to grow down...
a pattern that i converged on --- at least in postgres --- is to aggregate your data into json objects and then go from there. you don't need to know how many attributes (columns) should be in the result of your pivot. you can also do this in reverse (pivot from wide to long) with the same technique.
so for example if you have the schema `(obj_id, key, value)` in a long-formatted table, where an `obj_id` will have data spanning multiple rows, then you can issue a query like
``` SELECT obj_id, jsonb_object_agg(key, value) FROM table GROUP BY obj_id; ```
up to actual syntax...it's been awhile since i've had to do a task requiring this, so details are fuzzy but pattern's there.
so each row in your query result would look like a json document: `(obj_id, `{"key1": "value", "key2": "value", ...})`
see https://www.postgresql.org/docs/current/functions-json.html for more goodies.
In general the reason why is that if you have two random variables x and y, where x has any distribution (so for example x could even be "attack normandy on june 6" with certainty) and y is uniformly distributed across all n-bit strings (so it could be any string of n zeros and ones with equal probability), then you can show that x ^ y appears as if it is also uniformly distributed across all n-bit strings as well.
Because of this property it's used frequently in many higher order methods as well.
chess is in exp, the class of problems requiring exponential time to solve and exponential time to check. unlike p vs np we do know that exp \neq p.
some other good ones:
* the one we used in my undergrad course was fisher's complex variables which is great if you're learning for the purposes of applications. it's a cheap dover book.
* rudin's real and complex analysis (if theory is your thing. note that rudin's books, while great, do require a good background in math).
* as the article mentions, eli stein has a series of books on the four main branches of analysis. i believe the second book is on complex analysis.
you could try something like this for statements in a formal axiomatic system, but know that you're running up against things like the halting problem / entscheidungsproblem / godel incompleteness. so it may be possible to train a neural net to decide the veracity of a statement and do so more quickly than a human might, but you would inevitably be running up against things that are truly undecidable in nature. which is not like go or chess where although they are difficult, they are decidable.
it comes from topology, no?
It's not to save the ~10 minutes per year in faster key strokes to manipulate your code. It's about the way it shapes your thinking about how you code.
The function we are trying to compute is undecidable. Sure we as humans understand that there's a dichotomy here: if the program halts it won't halt; if it doesn't halt it will halt. But the function we are asked to compute must have one output on a given input. So a human, when given this program as input, is also unable to assign an output.
So humans also can't solve the halting problem, we are just able to recognize that the problem is undecidable.