pfedak

- it's true that there isn't a precise frequency needed for microwave ovens to heat food

- however, "polarity flipping" is just a description of electromagnetic radiation itself, and shooting enough EM radiation at food in a frequency range it absorbs will heat it up via dielectric heating

- microwaves have no relationship to any specific resonant frequency of water - the vibration frequencies are orders of magnitude higher https://en.wikipedia.org/wiki/Electromagnetic_absorption_by_... while rotation response inherently does not have a peak

- otherwise, yes, the motion of (polar) molecules induced by an electric field is indeed the mechanism of dielectric heating

This feels natural now, but other languages inherited a decision dating back to B, when logical operators like && and|| didn't exist, and the bitwise forms were used in their stead.

Another giveaway is that removing that line in the real optimization changes the output of the provided snippet if C < B. It feels like a hard sell to say GPT picked this line for that subtle reason based on information not provided, but explained it with something only correct at surface level.

It does create issues with determining which expressions are satisfied, since two different paths can meet at a merged trie vertex higher up, which requires the extra bookkeeping that kills it.

The final complexity discussion uses the graph size constraint gained by the "improvement" but doesn't consider how to handle the extra labeling meaningfully. Basically, the pre- and post-improvement algorithms put the exponential work in different spots, and the sloppiness of the algorithm description (I mean, really, why tell us you're using a stack for BFS and then have "determine the subset of satisfied constraints" as a step) makes it easy to ignore.

I'm also being a little generous with the algorithm itself. As described, some of the trie optimizations seem to make certain combinations of satisfied expressions impossible to notice, but I think it's not a big deal to make this part work. The properties of the trie structure (and of sorting the variables by occurrence, for that matter) don't seem to be used.

I also didn't mean to suggest those terms were invented by that article, just that they reflect the perspective of the people who use them. I'm assuming initial proponents of the "simple view of literacy" didn't describe it that way, just as we might call "whole language" something different if it ends up being discredited (cf. the focus on cueing in TFA).

It is careful to point out even minority criticism of phonics-centered instruction, while suggesting that disagreement with cueing approaches is a result of misunderstanding. It explicitly devalues "narrow" "experimental and quasi-experimental research" in favor of "decades of classroom-based and other forms of qualitative research" (how long has the experimental research been going on?). Even the naming feels slanted: the cueing approach gets called "whole language" or "balanced literacy" while opposing views start with "simple view of literacy". The "structured literacy" section ends with "although literacy researchers caution there is still much to learn about the brain and learning to read", while the cueing summary is free of similar caveats and emphasizes that it can adapt to individual students, as if other methods couldn't.

Ultimately it makes no actionable recommendations for what should actually be taught, except that no particular method should be mandated or banned, and that education should be "student-centered" (curious about the alternative...).

The "Labyrinth Sudoku" description feels like a classic language model speciousness. It doesn't actually work: you can't fit the digits 1-9 if you can't use all the cells, and it hasn't modified sudoku rules in a way that makes paths relevant. Maybe you can come up with a way to salvage it, but ChatGPT didn't.

The initial rules for Sum Delete should be read with this in mind: it sounds reasonable, but there's no reason to trust that it can make a puzzle at all, let alone a good one. Also, unsurprisingly, the provided puzzle isn't solvable (the 25 column requires use of the 9 in the first row).

Similarly, I'd love a critical analysis of the initial code. Did it guarantee solvability? An awful lot can be swept under "improving the design".

Beyond that, they were just picking a hypothesis without thinking how a bad plot could have been generated. It's interesting to note that the correct mapping, from their perspective, would have been the Taylor expansion of log(1+x), which would start x-x^2/2+x^3/3, so their goodness of fit metric (large R^2) wasn't a useful indicator, and there wasn't a meaningful place to cut off the degree.

retrieves other issues that user has commented on. Some have code, but it's usually examples/boilerplate except when previous comments cited a relevant snippet.

The output doesn't give me much confidence that, if we tweaked the problem slightly to make the greedy approach not work (e.g. certain characters/positions can't be replaced with backspace), we'd still get a working solution out. We might get something that looked extremely similar to this, but didn't actually solve the problem.

As I said, this isn't too different from what I'd consider human performance on these problems, but it makes being able to trust the output (and the model's confidence in the output) even more important.

> The letter I [...] would be referred to with the phrase I per se, I, which means in Latin "I by itself (is the word) I."

It's the letter I, not the word. It's like a half-remembered explanation

Going a step further, changing the "functions" over time can create smoothly animated fractals. Electric Sheep (https://electricsheep.org/) is a screensaver version of this which doubles as a distributed computing network to generate them. It also mixes in non-linear transformations which makes for some impressive, mesmerizing patterns.

The observation that some lines look strange is about as meaningful as the same observation on an any given map projection. It's definitely true, but it all depends on the choice of mapping function, nothing inherent to spherical geometry.

I choose map projections for a particular reason: as has already been pointing out, there's no connection between this "strict" definition and an exponential coordinate transform. Any function mapping the axes that grows faster than polynomial would produce the desired behavior (essentially, you need the ratio between z and x on a line a*x + b*z = c to approach zero or infinity), but would produce different "line" shapes. This choice is entirely arbitrary, and is in fact equivalent to simply mapping the underlying space by a related transformation and then using a normal projective transformation.

uniform vec3 mouse; uniform vec2 resolution; uniform sampler2D texture;

vec3 computeNormal( vec4 n ) {

  // pixel scale
  vec2 un = 1.0 / resolution;
  vec2 uv = gl_FragCoord.xy / resolution;

  // tex sample neighbour-4;
  vec3 n_r = texture2D( texture, uv + vec2( 1., 0. ) * un ).xyz;
  vec3 n_l = texture2D( texture, uv - vec2( 1., 0. ) * un ).xyz;
  vec3 n_u = texture2D( texture, uv + vec2( 0., 1. ) * un ).xyz;
  vec3 n_d = texture2D( texture, uv - vec2( 0., 1. ) * un ).xyz;

  // partial differences n-4;
  vec4 dn = vec4( n.z );
  dn -= vec4( n_r.z, n_l.z, n_u.z, n_d.z );

  // right - left, up - down;
  vec2 xy = vec2( dn.x - dn.y, dn.z - dn.w );
  xy += n_r.xy + n_l.xy + n_u.xy + n_d.xy;
  xy *= 0.89;

  float z = length(xy) * 0.1;

  return vec3( xy, z ) * 0.25;

void main() {

  vec2 uv = gl_FragCoord.xy / resolution;

  // normal sampling
  vec4 height = texture2D( texture, uv );

  float vel = height.a; // previous velocity
  float elasticity = 0.002;
  float viscosity = 0.06;
  vel += - (height.z - 0.01) * elasticity - vel * viscosity;

  // compute normal advection
  vec3 normal = computeNormal( height );
  normal.z += height.z + vel;

  float dist = distance( mouse.xy,  gl_FragCoord.xy);
  float mouseRadius = 10.0;
  float peak = 1.9; // max-height
  
  if ( dist <= mouseRadius ) {
    float dst = ( mouseRadius - dist ) / mouseRadius;
    normal.z += pow( abs(dst), 1.9 ) * peak * 2.5;
    normal.xy -= normal.xy * pow( abs(dst), 1.9 ) * 0.1;
    normal.z = min( peak, normal.z );
  }

  gl_FragColor = clamp( vec4( normal, vel ), -1.0, 1.0);

}

A cluster randomised trial of cloth masks compared with medical masks in healthcare workers

Not only is your presentation of its results in bad faith, you rely on people not reading the article.