The specification says that the syntax of expressions in this thing is `E ::= t | E E`. This is a bit confusing, because it might lead you to believe that all expressions just look like `t t t t t t t`. In reality, you are supposed to keep the implied bracketing, so expressions really look like `(t t) (t ((t t) (t t)))` (note that at the top level and in each parenthesis, there always exactly two subexpressions). Essentially, the space character becomes a binary operator (similar to how we often write multiplication with no symbol).
The expressions are a bit heavy on parentheses, so we say that this binary operator is left associative. This means that an expression `a b c` should be interpreted as `(a b) c`, an expression `a b c d` should be interpreted as `((a b) c) d`, and so on. If you think about it, this means that you can always get rid of an opening parenthesis at the left edge of an expression, i.e. we can assume that an expression always start without one.
With this out of the way, we can now understand where the trees come from: As there is only one terminal symbol, `t`, after removing unnecessary parentheses, every expression will always start with `t`, which is followed by a number of other expressions. To draw this as a tree, draw a node representing the initial `t`, and a sub-tree for each of the follow-up expressions (by applying the same procedure to them).
In this view, the semantic rules at the top of the specification page now tell you how to "simplify" a tree whenever there is a node with three or more sub-trees, or alternatively, how to reduce an expression that is a `t` followed by three or more sub-expressions. (In the syntax view, you replace the `t` and the first three expressions following it by whats on the right of the arrow. In the tree view, you replace the node and its first three children by some other sub-tree, then you attach the remaining children to the root of the new sub-tree.)
I know that there used to be some oversights where things where missing from the Law (like how to distinguish immediate effects from permanent effects on cards based on whether the box is paper or stone) but all of them have been resolved by now.
I think they mean memorize. Most students simply lack the mathematical experience to internalize a definition correctly without simply memorizing it. They will forget an "only if", or accidentally swap two quantifiers around, or conflate two variables that need to be kept separate, etc.
This is okay! They're students on the way to gain that experience. At some point you can and will go over to internalizing, instead. But as advice to students just starting out, memorizing is the way to go.
Yeah, it’s the same in Germany. (And to add insult to injury, people in places with renewable generation often pay higher grid fees due to the investments necessary to connect all the new plants.)
Yes, but that's partly a consequence of how the German electricity market operates and the neglected state of its infrastructure, isn't it?
Wind power and other intermittent sources create grid instability, which drives up costs.
And to my knowledge, Germany has chosen not to have different bidding markets within the country (or has at least kept prices consistent across its four markets) to protect vital industries in the west?
This is how the energy grid operates everywhere, it's not some uniquely German mistake. Renewables require an incredibly huge grid investment - it's the same story they keep telling about external costs, only this time they don't want to hear it. I don't want to subsidize others' cheaper energy, I don't have any place to put my panels and batteries, I was happy with how it was before. But they would do anything to avoid the fees when they can.
Would you buy wind power if somebody provided that close to where you live? The way the system currently works is that you see no benefit at all if wind towers are close to where you live. Because somebody on the complete opposite side of the country only has access to gas power and the national prices are set for the highest price needed anywhere in the country. You are effectively subsidizing those people. Not the other way around. Your rates are high because gas is expensive and has to be shipped in in LNG form these days. No matter where you live in the country.
Gas is expensive because stable demand has been replaced by spikes based on renewable availability. I don't have any opportunity to get any renewable power - it's cold and there's no space for grid scale wind or solar.
This doesn't make any sense. Germany has storage for more than a season's worth of natural gas. The price went up because Russia stopped selling cheap gas to western Europe after its attack on Ukraine.
Myself I'm not affected by this. It's used too much as a counter argument, it's not universally applicable - even in Germany. The price spikes were happening before the war too.
> This is how the energy grid operates everywhere, it's not some uniquely German mistake.
The fact that Bavaria keeps sabotaging north-south transmission capacity is a uniquely German mistake, as is the insistence of Bavaria and Baden-Württemberg to keep the single pricing zone.
I have not once seen a formulae-as-images solution that I would consider acceptable, aesthetically. Common problems are:
- It almost impossible to align the baseline of the formula to the baseline of the surrounding text.
- Often, images are only used for "complex" formulae, while simple ones are implemented using normal typesetting. This resolves the baseline issue for simple formulae, but now the fonts between simple and complex formulae don't match. (This requires extra concentration for the reader, as in other contexts, different font styles are frequently used meaningfully.)
But the question here is not looking for a generator, because it would be okay if some group elements are only reached during the application of the sequence. (For the sequence to be a generator, all group elements need to be reached at the end of some full application of the sequence.)
The Hamiltonian cycle sequence from the original post is not a generator, but it visits every state. The question is: Is there a significantly shorter sequence that (when repeated) does the same?
We can give a concrete example that non-Abelian groups can satisfy this with S_3, which is the smallest non-Abelian group. Swap the first two elements; then swap the last two. Repeat three times. You get the sequence
Yes, but I definitely also see the opposite quite a bit: Somebody several layers down thought that something was an edge case, resolved it in a strange way, and now you have a chain of stuff above it dealing with the edge case because the bottom layer took a wrong turn.
The most common examples are empty collections: either disallowing them even though it would be possible to handle them, or making a strange choice like using vacuous falsity, i.e.
all [] == False
(Just for illustration what I mean by "vacuous falsity", Python's all correctly returns True).
Now, every layer above has to special-case these as well, even if they would be a completely normal case otherwise.
Your example perfectly illustrates oversimplification: attempt to stuff categorical variable into another of lower order. If a language has absence of value available as an expressible concept (nullability), then a list is at least 3-way categorical variable: absence of value, empty list, non-empty list. Any attempts to stuff that into a binary truthy value will eventually leak one way or another.
The specification says that the syntax of expressions in this thing is `E ::= t | E E`. This is a bit confusing, because it might lead you to believe that all expressions just look like `t t t t t t t`. In reality, you are supposed to keep the implied bracketing, so expressions really look like `(t t) (t ((t t) (t t)))` (note that at the top level and in each parenthesis, there always exactly two subexpressions). Essentially, the space character becomes a binary operator (similar to how we often write multiplication with no symbol).
The expressions are a bit heavy on parentheses, so we say that this binary operator is left associative. This means that an expression `a b c` should be interpreted as `(a b) c`, an expression `a b c d` should be interpreted as `((a b) c) d`, and so on. If you think about it, this means that you can always get rid of an opening parenthesis at the left edge of an expression, i.e. we can assume that an expression always start without one.
With this out of the way, we can now understand where the trees come from: As there is only one terminal symbol, `t`, after removing unnecessary parentheses, every expression will always start with `t`, which is followed by a number of other expressions. To draw this as a tree, draw a node representing the initial `t`, and a sub-tree for each of the follow-up expressions (by applying the same procedure to them).
In this view, the semantic rules at the top of the specification page now tell you how to "simplify" a tree whenever there is a node with three or more sub-trees, or alternatively, how to reduce an expression that is a `t` followed by three or more sub-expressions. (In the syntax view, you replace the `t` and the first three expressions following it by whats on the right of the arrow. In the tree view, you replace the node and its first three children by some other sub-tree, then you attach the remaining children to the root of the new sub-tree.)