CompressedGemma/Raon-1-mini-preview-Q2K_Q4

This is not capable compared to Qwen, it is actually awful for anything that is not light coding or chatbot usage.

Here is an example of its thought process when told to make a rotating Tesseract (which Qwen Q2 can do)

A rotating tesseract visualization: I'll write a nice, self-contained HTML file with JavaScript — 4D tesseract rendering with perspective projection. Let me think about the math.

A tesseract has 8 vertices: combinations of coordinates like (±1, ±1, ±1, ±1). We rotate in 4D — rotations on two planes simultaneously (XY and UV planes). Projection from 4D to 3D (or to 2D for screen).

Common approach: 3D projection from 4D via perspective projection. Keep it simple: use a rotation matrix in 4D (XY rotation and UV rotation), then apply perspective projection from 4D to 3D then to 2D screen space (screen space with y axis... standard perspective: x' = x*scale/(focal - z), etc).

Let me build a reasonable implementation:

• 4D coordinates: (x, y, z, w)
• Rotation: rotate XY plane and ZW plane (XY+Z rotation in 4D): apply xy rotation matrix to first two, uv matrix for last two.
• projection: 4D -> 3D -> 2D. Projection from 4D to 3D perspective projection (first two axes), then a 3D perspective to 2D.

Simple approach: 4D -> 3D projection: x4, y4, z4 -> project onto x4,y4,z4 with perspective: x' = x/(z+focal), etc... then 3D -> 2D: x'=x/(z+focal), y'=y/(z+focal) plus perspective. Then 2D draw on screen with rotation about screen plane.

Let me write a clean implementation:

  // 4D rotation matrix applied to 4D vector
  function rotate4(a, thetaXY, thetaUV) {
    const xy = rotate2D(a[0], a[1], thetaXY);
    const uv = rotate2D(a[2], a[3], thetaUV);
    return [xy[0], xy[1], uv[0], uv[1]];
  }

Projection from 4D to 3D: project x,y,z with w as depth? Common 4D projection: project onto first three dims with x/(focal + w)... Let me keep it reasonably standard: project to 3D with perspective w: x4 = x/(w + focal)... I'll implement: project x3 = x/(z+z0) etc from 4D to 3D using w as depth axis? Actually common projection: first project to 3D: (x3, y3, z3) = (x/(z+f), y/(z+f), z + w/(z+f)...). Simplest: x3 = x / (z + f), y3 = y / (z + f), z3 = z... Hmm, standard 4D projection: x = x4 / (z4 + focal), y = y4/(z4 + f), z = w4/(z4 + f)... Let me implement a simple projection:

For 4D point (x,y,z,w): x' = x / (z + focal) y' = y / (z + f) z' = ... — maybe w/(z+f)

To keep it simple and not too complex, use a 4D-to-3D projection where last dimension is used for depth:

x3 = x / (z + f), y3 = y / (z + f), z3 = w / (z + f)... Hmm, that loses z. Standard is n-dimensional perspective: for each dimension i, projection uses z for denominator. Let me implement:

projection of point (x0,y0,z0,w0): x = x0/(z0 + focal), y = y0/(z0 + f), z = w0/(z0 + f)... That's a common formulation (project to 3D where last two dims become z and depth). Actually common formula: x = x4/(z4 + f), y = y4/(z4 + f), z = w4/(z4 + f). Hmm, common convention: (x,y,z) = (x4/z4, y4/z4, z4/(z4+w4)?)... Let me not overthink; use a reasonable projection:

  function project4(p) {
    x = p[0]; y = p[1]; z = p[2]; w = p[3];
    // project 4D to 3D
    z = z + f (in 3D point)
  }

Let me design: project 4D -> 3D using w as the extra axis: x4/(z4 + f), y4/(z4 + f), z = ... Actually keep it as: z = z + w / ... Let me just use standard formula from common sources:

Given n-dim point (x0..yn-1): x = x0/(zn + f), y = y0/(zn + f)... For 4D: first z, y → z, last x. Common formulation: (x4,y4,z4,w4): x = x/(z+f), y = y/(z+f), z = z/(z+f), w = w/(z+f)... Hmm.

Simplest: x = x/(z + f), y = y/(z + f), z = z + w/(z + f)... I won't over-engineer; let me use: project to (x', y', z') as:

x' = x / (z + f), y' = y / (z + f), z' = z + w / (z + f)? Something reasonable: z' = (z + w)/(z + f)... Actually for 4D: x = x/(z+f), y = y/(z+f), z = z/(z + f)... hmm, actually common formulation: x = x/(z + f), y = y/(z + f), z = z, w = w / (z + f)? Let me just implement:

  function project(p) {
    const z = p[2]; f = focal;
    const fz = f / Math.max(z + f, ...)...
  }

Hmm, let me pick a standard formulation: (x', y', z') = (x/(z+f), y/(z+f), z + w/(z+f)?) Eh.

Common standard: For a point with n=4 dims: x = x0 / (z + f), y = y0 / (z + f), z = z + w / (z + f)... Let me use x' = x/(z+f), y' = y/(z+f), z' = z + w/(z+f)... Fine — I'll project as: z' = (w + z)... Actually common formulation (from common projection formula): n-dim projection: x_proj = x / (z + f), y_proj = y / (z + f), z_proj = z / (z + f)... and 4D variant where first n-1 axes and z is the extra axis... Let me just do:

  x' = x / (z + f)
  y' = y / (z + f)
  z' = z + w / (z + f)

Hmm, wait — standard formula for projection from n dimensions to 3D: x = x0/(z0 + f), y = y0/(z0 + f), z = z0 + (w0 * f)/(...)... Let me instead use: x = x/(z + f), y = y/(z + f), z = z + ... I'll pick: x = x/(z + f), y = y/(z + f), z = (z + w)/(z + f)... Hmm.

Honestly, the simplest sane formulation: project n-dim as: for each of the last dims: x = x/(z + f), y = y/(z + f), z = z + (w / (z + f))? Not correct. Let me just do x/(z+f), y/(z+f), z = z + ... — whatever. Let me keep it as:

  const x = x0 / (z + f)
  const y = y0 / (z + f)
  const z = z + w + ...

Simplest reasonable formulation from literature: For projection n-dim: x = x/(z + f), y = y/(z + f), z = z + w / (z + f)... hmm, that's not right; common formulation (x0...yn-1): z = z0 / (z + f)... Let me just do this:

  function project4(a, f) {
    const z = p[2];
    f = f / (z + f)... // standard formula: f = z / (z + f)...
    x = a[0] * (z / (z + f))?

OK, I won't overthink. Common formulation from n-D to 3D: x = x/(z + f), y = y/(z + f), z = (z + w)/(z + f)... Wait — actually the common formulation is: x = x0/z0, y = y0/z0, z = z0 + w0 / (z + f)... I'll settle:

x = x/(z + f), y = y/(z + f), z = z + ... — Let me do x = x/(z + f), y = y/(z + f), z = z + w/(z + f)? Hmm.

Actually the common projection formula (Wikipedia): x' = x/(z + f), y' = y/(z + f), z = z... etc etc