# Nakafa Framework: LLM

URL: https://nakafa.com/en/subject/high-school/11/mathematics/geometric-transformation/reflection-over-x-axis
Source: https://raw.githubusercontent.com/nakafaai/nakafa.com/refs/heads/main/packages/contents/subject/high-school/11/mathematics/geometric-transformation/reflection-over-x-axis/en.mdx

Output docs content for large language models.

---

import { LineEquation } from "@repo/design-system/components/contents/line-equation";
import { getColor } from "@repo/design-system/lib/color";

export const metadata = {
  title: "Reflection over X Axis",
  description: "Master X-axis reflection transformations. Learn how coordinates change (x,y) to (x,-y) with triangles, lines, and interactive visualizations.",
  authors: [{ name: "Nabil Akbarazzima Fatih" }],
  date: "05/10/2025",
  subject: "Geometric Transformation",
};

## Understanding Reflection across the X-Axis

Reflection across the X-axis is a type of geometric transformation that moves every point of an object to a new position symmetrical to the X-axis. Imagine the X-axis as a flat mirror.

If a point <InlineMath math="P" /> has coordinates <InlineMath math="(x,y)" />, then its reflection, which we'll call <InlineMath math="P'" />, will have the same <InlineMath math="x" />-coordinate, but its <InlineMath math="y" />-coordinate will be the negative of the original <InlineMath math="y" /> value.

Mathematically, if the initial point is <InlineMath math="P(x,y)" />, then after reflection across the X-axis, its image is <InlineMath math="P'(x,-y)" />.

### Visualizing Points and Their Reflections

Let's observe some points and their reflections after being mirrored across the X-axis.

Notice how the <InlineMath math="y" />-coordinate changes sign, while the <InlineMath math="x" />-coordinate remains the same.

<LineEquation
  title="Point Reflections Across the X-Axis"
  description={
    <>
      Visualization of points <InlineMath math="A, B, C, D" /> and their
      reflections <InlineMath math="A', B', C', D'" /> after mirroring across
      the X-axis.
    </>
  }
  cameraPosition={[0, 0, 15]}
  showZAxis={false}
  data={[
    ...[
      { x: -5, y: 2, label: "A" },
      { x: -3, y: 1, label: "B" },
      { x: 1, y: 2, label: "C" },
      { x: 4, y: -2, label: "D" },
    ].map((p, i) => ({
      points: [
        { x: p.x, y: p.y, z: 0 },
        { x: p.x, y: p.y, z: 0 }, // Single point
      ],
      color: getColor("AMBER"),
      labels: [{ text: p.label, at: 0, offset: [0.3, 0.3, 0] }],
      showPoints: true,
    })),
    ...[
      { x: -5, y: -2, label: "A'" },
      { x: -3, y: -1, label: "B'" },
      { x: 1, y: -2, label: "C'" },
      { x: 4, y: 2, label: "D'" },
    ].map((p, i) => ({
      points: [
        { x: p.x, y: p.y, z: 0 },
        { x: p.x, y: p.y, z: 0 }, // Single point
      ],
      color: getColor("CYAN"),
      labels: [{ text: p.label, at: 0, offset: [0.3, 0.3, 0] }],
      showPoints: true,
    })),
  ]}
/>

Based on the interactive visualization above, we can observe the relationship between the original points (pre-image) and their reflections (image) as follows:

- Point <InlineMath math="A(-5,2)" /> becomes <InlineMath math="A'(-5,-2)" />
- Point <InlineMath math="B(-3,1)" /> becomes <InlineMath math="B'(-3,-1)" />
- Point <InlineMath math="C(1,2)" /> becomes <InlineMath math="C'(1,-2)" />
- Point <InlineMath math="D(4,-2)" /> becomes <InlineMath math="D'(4,2)" />

The visible pattern is that the <InlineMath math="x" /> value remains constant, and the <InlineMath math="y" /> value changes sign (becomes its opposite).

## Property of Reflection across the X-Axis

Based on the observations above, we can formulate the property of reflection across the X-axis:

<BlockMath math="P(x,y) \xrightarrow{\text{X-axis}} P'(x,-y)" />

This means the image of point <InlineMath math="P(x,y)" /> reflected across the X-axis is <InlineMath math="P'(x,-y)" />. The X-axis in this case acts as the line <InlineMath math="y=0" />.

## Application Examples

### Reflecting a Triangle

Determine the image of triangle <InlineMath math="ABC" /> with vertices <InlineMath math="A(-1,4)" />, <InlineMath math="B(2,1)" />, and <InlineMath math="C(-2,-1)" /> reflected across the X-axis.

To determine the image of triangle <InlineMath math="ABC" />, we apply the reflection property to each of its vertices:

<div className="flex flex-col gap-4">
  <BlockMath math="A(-1,4) \xrightarrow{\text{X-axis}} A'(-1,-4)" />
  <BlockMath math="B(2,1) \xrightarrow{\text{X-axis}} B'(2,-1)" />
  <BlockMath math="C(-2,-1) \xrightarrow{\text{X-axis}} C'(-2,1)" />
</div>

Consequently, the image of triangle <InlineMath math="ABC" /> is triangle <InlineMath math="A'B'C'" /> with vertices <InlineMath math="A'(-1,-4)" />, <InlineMath math="B'(2,-1)" />, and <InlineMath math="C'(-2,1)" />.

<LineEquation
  title={
    <>
      Reflection of Triangle <InlineMath math="ABC" /> across the X-Axis
    </>
  }
  description={
    <>
      Visualization of triangle <InlineMath math="ABC" /> and its
      reflection <InlineMath math="A'B'C'" /> after mirroring across
      the X-axis.
    </>
  }
  cameraPosition={[0, 0, 15]}
  showZAxis={false}
  data={[
    // Triangle ABC (Original)
    ...[
      {
        from: { x: -1, y: 4, z: 0, label: "A" },
        to: { x: 2, y: 1, z: 0, label: "B" },
      },
      {
        from: { x: 2, y: 1, z: 0, label: "B" },
        to: { x: -2, y: -1, z: 0, label: "C" },
      },
      {
        from: { x: -2, y: -1, z: 0, label: "C" },
        to: { x: -1, y: 4, z: 0, label: "A" },
      },
    ].map((segment) => ({
      points: [segment.from, segment.to],
      color: getColor("ORANGE"),
      showPoints: true,
      labels: [
        {
          text: segment.from.label,
          at: 0,
          offset: [0.3, 0.3, 0],
        },
        { text: segment.to.label, at: 1, offset: [0.3, 0.3, 0] },
      ],
    })),
    // Triangle A'B'C' (Reflected)
    ...[
      {
        from: { x: -1, y: -4, z: 0, label: "A'" },
        to: { x: 2, y: -1, z: 0, label: "B'" },
      },
      {
        from: { x: 2, y: -1, z: 0, label: "B'" },
        to: { x: -2, y: 1, z: 0, label: "C'" },
      },
      {
        from: { x: -2, y: 1, z: 0, label: "C'" },
        to: { x: -1, y: -4, z: 0, label: "A'" },
      },
    ].map((segment) => ({
      points: [segment.from, segment.to],
      color: getColor("PURPLE"),
      showPoints: true,
      labels: [
        {
          text: segment.from.label,
          at: 0,
          offset: [0.3, 0.3, 0],
        },
        { text: segment.to.label, at: 1, offset: [0.3, 0.3, 0] },
      ],
    })),
  ]}
/>

### Reflecting a Line

If a line has the equation <InlineMath math="2x - 3y = 0" /> and is reflected across the X-axis, determine the equation of its reflected line.

**Alternative Solution:**

Let an arbitrary point <InlineMath math="P(a,b)" /> lie on the line <InlineMath math="2x - 3y = 0" />. Then, the following holds:

<BlockMath math="2a - 3b = 0" />

The point <InlineMath math="P(a,b)" /> reflected across the X-axis produces the image <InlineMath math="P'(a,-b)" />.

To obtain the equation of the reflected line, we substitute the coordinates of the image into new variables. Let <InlineMath math="x' = a" /> and <InlineMath math="y' = -b" />.

From this, we get <InlineMath math="a = x'" /> and <InlineMath math="b = -y'" />.

Substitute <InlineMath math="a = x'" /> and <InlineMath math="b = -y'" /> into the original equation <InlineMath math="2a - 3b = 0" />:

<div className="flex flex-col gap-4">
  <BlockMath math="2(x') - 3(-y') = 0" />
  <BlockMath math="2x' + 3y' = 0" />
</div>

Since <InlineMath math="x'" /> and <InlineMath math="y'" /> are arbitrary variables representing the coordinates on the reflected line, we can rewrite them as <InlineMath math="x" /> and <InlineMath math="y" />.

Thus, the equation of the reflected line is:

<div className="flex flex-col gap-4">
  <BlockMath math="2x + 3y = 0" />
  <LineEquation
    title={
      <>
        Reflection of Line <InlineMath math="2x - 3y = 0" /> across the X-Axis
      </>
    }
    description={
      <>
        The original line <InlineMath math="2x - 3y = 0" /> (lime green) and its
        reflection <InlineMath math="2x + 3y = 0" /> (magenta) after mirroring.
      </>
    }
    cameraPosition={[0, 0, 15]}
    showZAxis={false}
    data={[
      {
        // Original Line: 2x - 3y = 0  => y = (2/3)x
        points: [
          { x: -6, y: (2 / 3) * -6, z: 0 },
          { x: 6, y: (2 / 3) * 6, z: 0 },
        ],
        color: getColor("LIME"),
        labels: [{ text: "2x - 3y = 0", at: 1, offset: [0.5, 0.5, 0] }],
      },
      {
        // Reflected Line: 2x + 3y = 0 => y = -(2/3)x
        points: [
          { x: -6, y: -(2 / 3) * -6, z: 0 },
          { x: 6, y: -(2 / 3) * 6, z: 0 },
        ],
        color: getColor("MAGENTA"),
        labels: [{ text: "2x + 3y = 0", at: 1, offset: [0.5, -0.5, 0] }],
      },
    ]}
  />
</div>

This shows how the equation of a line changes after being reflected across the X-axis.