# Nakafa Framework: LLM

URL: https://nakafa.com/en/subject/high-school/11/mathematics/circle/circle-and-chord
Source: https://raw.githubusercontent.com/nakafaai/nakafa.com/refs/heads/main/packages/contents/subject/high-school/11/mathematics/circle/circle-and-chord/en.mdx

Output docs content for large language models.

---

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

export const metadata = {
  title: "Circle and Chord",
  description: "Explore circle and chord relationships. Understand theorems, properties, and solve chord length problems with clear examples and step-by-step solutions.",
  authors: [{ name: "Nabil Akbarazzima Fatih" }],
  date: "05/18/2025",
  subject: "Circle",
};

## Definition of Chord

A chord is a line segment that connects two points on a circle. Unlike a diameter that passes through the center of the circle, a chord can be positioned anywhere as long as both endpoints lie on the circle.

<LineEquation
  title="Chords on a Circle"
  description="Various chords with different lengths on a circle."
  data={[
    {
      points: Array.from({ length: 361 }, (_, i) => {
        const angle = (i * Math.PI) / 180;
        return {
          x: 3 * Math.cos(angle),
          y: 3 * Math.sin(angle),
          z: 0,
        };
      }),
      color: getColor("PURPLE"),
      showPoints: false,
    },
    {
      points: [{ x: 0, y: 0, z: 0 }],
      color: getColor("ORANGE"),
      showPoints: true,
      labels: [{ text: "O", at: 0, offset: [-0.3, -0.3, 0] }],
    },
    {
      points: (() => {
        const angle1 = Math.PI / 6;
        const angle2 = Math.PI / 3;
        return [
          { x: 3 * Math.cos(angle1), y: 3 * Math.sin(angle1), z: 0 },
          { x: 3 * Math.cos(angle2), y: 3 * Math.sin(angle2), z: 0 },
        ];
      })(),
      color: getColor("CYAN"),
      showPoints: true,
      labels: [
        { text: "A", at: 0, offset: [0.3, 0.3, 0] },
        { text: "B", at: 1, offset: [0.3, 0.3, 0] },
      ],
    },
    {
      points: (() => {
        const angle1 = (2 * Math.PI) / 3;
        const angle2 = (5 * Math.PI) / 6;
        return [
          { x: 3 * Math.cos(angle1), y: 3 * Math.sin(angle1), z: 0 },
          { x: 3 * Math.cos(angle2), y: 3 * Math.sin(angle2), z: 0 },
        ];
      })(),
      color: getColor("TEAL"),
      showPoints: true,
      labels: [
        { text: "C", at: 0, offset: [-0.3, 0.3, 0] },
        { text: "D", at: 1, offset: [-0.3, 0.3, 0] },
      ],
    },
    {
      points: (() => {
        const angle1 = (7 * Math.PI) / 6;
        const angle2 = (3 * Math.PI) / 2;
        return [
          { x: 3 * Math.cos(angle1), y: 3 * Math.sin(angle1), z: 0 },
          { x: 3 * Math.cos(angle2), y: 3 * Math.sin(angle2), z: 0 },
        ];
      })(),
      color: getColor("PINK"),
      showPoints: true,
      labels: [
        { text: "E", at: 0, offset: [-0.3, -0.3, 0] },
        { text: "F", at: 1, offset: [0, -0.5, 0] },
      ],
    },
  ]}
  cameraPosition={[0, 0, 10]}
  showZAxis={false}
/>

In the figure above, <InlineMath math="AB" />, <InlineMath math="CD" />, and <InlineMath math="EF" /> are chords with different lengths.

## Properties of Chords

### Equal Length Chords

Two chords of equal length have the same distance from the center of the circle.

<LineEquation
  title="Equal Length Chords"
  description="Two chords with equal length have the same distance from the center."
  data={[
    {
      points: Array.from({ length: 361 }, (_, i) => {
        const angle = (i * Math.PI) / 180;
        return {
          x: 4 * Math.cos(angle),
          y: 4 * Math.sin(angle),
          z: 0,
        };
      }),
      color: getColor("PURPLE"),
      showPoints: false,
    },
    {
      points: [{ x: 0, y: 0, z: 0 }],
      color: getColor("ORANGE"),
      showPoints: true,
      labels: [{ text: "O", at: 0, offset: [-0.3, -0.3, 0] }],
    },
    {
      points: (() => {
        const y = 2;
        const x = Math.sqrt(16 - y * y);
        return [
          { x: -x, y: y, z: 0 },
          { x: x, y: y, z: 0 },
        ];
      })(),
      color: getColor("CYAN"),
      showPoints: true,
      labels: [
        { text: "P", at: 0, offset: [-0.3, 0.3, 0] },
        { text: "Q", at: 1, offset: [0.3, 0.3, 0] },
      ],
    },
    {
      points: (() => {
        const y = -2;
        const x = Math.sqrt(16 - y * y);
        return [
          { x: -x, y: y, z: 0 },
          { x: x, y: y, z: 0 },
        ];
      })(),
      color: getColor("TEAL"),
      showPoints: true,
      labels: [
        { text: "R", at: 0, offset: [-0.3, -0.3, 0] },
        { text: "S", at: 1, offset: [0.3, -0.3, 0] },
      ],
    },
    {
      points: [
        { x: 0, y: 0, z: 0 },
        { x: 0, y: 2, z: 0 },
      ],
      color: getColor("AMBER"),
      showPoints: false,
      smooth: false,
      labels: [{ text: "d₁", at: 1, offset: [0.5, 0, 0] }],
    },
    {
      points: [
        { x: 0, y: 0, z: 0 },
        { x: 0, y: -2, z: 0 },
      ],
      color: getColor("AMBER"),
      showPoints: false,
      smooth: false,
      labels: [{ text: "d₂", at: 1, offset: [0.5, 0, 0] }],
    },
  ]}
  cameraPosition={[0, 0, 12]}
  showZAxis={false}
/>

If <InlineMath math="PQ = RS" />, then the distance from center <InlineMath math="O" /> to chord <InlineMath math="PQ" /> equals the distance from <InlineMath math="O" /> to chord <InlineMath math="RS" />, that is <InlineMath math="d_1 = d_2" />.

### Line from Center Perpendicular to Chord

A line drawn from the center of a circle perpendicular to a chord divides the chord into two equal parts.

<LineEquation
  title="Perpendicular Line from Center"
  description="A line from the center perpendicular to a chord bisects it."
  data={[
    {
      points: Array.from({ length: 361 }, (_, i) => {
        const angle = (i * Math.PI) / 180;
        return {
          x: 5 * Math.cos(angle),
          y: 5 * Math.sin(angle),
          z: 0,
        };
      }),
      color: getColor("PURPLE"),
      showPoints: false,
    },
    {
      points: [{ x: 0, y: 0, z: 0 }],
      color: getColor("ORANGE"),
      showPoints: true,
      labels: [{ text: "O", at: 0, offset: [-0.3, -0.3, 0] }],
    },
    {
      points: (() => {
        const angle1 = Math.PI / 4;
        const angle2 = (3 * Math.PI) / 4;
        return [
          { x: 5 * Math.cos(angle1), y: 5 * Math.sin(angle1), z: 0 },
          { x: 5 * Math.cos(angle2), y: 5 * Math.sin(angle2), z: 0 },
        ];
      })(),
      color: getColor("CYAN"),
      showPoints: true,
      labels: [
        { text: "A", at: 0, offset: [0.3, 0.3, 0] },
        { text: "B", at: 1, offset: [-0.3, 0.3, 0] },
      ],
    },
    {
      points: (() => {
        const midAngle = (Math.PI / 4 + (3 * Math.PI) / 4) / 2;
        const midX = 5 * Math.cos(midAngle);
        const midY = 5 * Math.sin(midAngle);
        const chordMidX =
          (5 * Math.cos(Math.PI / 4) + 5 * Math.cos((3 * Math.PI) / 4)) / 2;
        const chordMidY =
          (5 * Math.sin(Math.PI / 4) + 5 * Math.sin((3 * Math.PI) / 4)) / 2;
        return [
          { x: 0, y: 0, z: 0 },
          { x: chordMidX, y: chordMidY, z: 0 },
        ];
      })(),
      color: getColor("PINK"),
      showPoints: true,
      smooth: false,
      labels: [{ text: "M", at: 1, offset: [0, 0.5, 0] }],
    },
    {
      points: (() => {
        const chordMidX =
          (5 * Math.cos(Math.PI / 4) + 5 * Math.cos((3 * Math.PI) / 4)) / 2;
        const chordMidY =
          (5 * Math.sin(Math.PI / 4) + 5 * Math.sin((3 * Math.PI) / 4)) / 2;
        const perpX = chordMidX + 0.5;
        const perpY = chordMidY;
        return [
          { x: chordMidX - 0.3, y: chordMidY, z: 0 },
          { x: chordMidX - 0.3, y: chordMidY + 0.3, z: 0 },
          { x: chordMidX, y: chordMidY + 0.3, z: 0 },
        ];
      })(),
      color: getColor("AMBER"),
      showPoints: false,
      smooth: false,
    },
  ]}
  cameraPosition={[0, 0, 15]}
  showZAxis={false}
/>

In the figure above, <InlineMath math="OM \perp AB" /> and <InlineMath math="M" /> is the midpoint of chord <InlineMath math="AB" />, so <InlineMath math="AM = MB" />.

## Chord Length

### Chord Length Formula

To calculate the length of a chord, we can use the formula:

<BlockMath math="AB = 2r \sin\left(\frac{\theta}{2}\right)" />

Where:

- <InlineMath math="r" /> = radius of the circle
- <InlineMath math="\theta" /> = central angle subtending the chord (in radians)

The relationship between central angle and chord length can be visualized as follows:

<LineEquation
  title="Central Angle and Chord"
  description="Relationship between central angle and chord length."
  data={[
    {
      points: Array.from({ length: 361 }, (_, i) => {
        const angle = (i * Math.PI) / 180;
        return {
          x: 4 * Math.cos(angle),
          y: 4 * Math.sin(angle),
          z: 0,
        };
      }),
      color: getColor("PURPLE"),
      showPoints: false,
    },
    {
      points: [{ x: 0, y: 0, z: 0 }],
      color: getColor("ORANGE"),
      showPoints: true,
      labels: [{ text: "O", at: 0, offset: [-0.3, -0.3, 0] }],
    },
    {
      points: (() => {
        const angle1 = Math.PI / 6;
        const angle2 = (2 * Math.PI) / 3;
        return [
          { x: 4 * Math.cos(angle1), y: 4 * Math.sin(angle1), z: 0 },
          { x: 4 * Math.cos(angle2), y: 4 * Math.sin(angle2), z: 0 },
        ];
      })(),
      color: getColor("CYAN"),
      showPoints: true,
      labels: [
        { text: "P", at: 0, offset: [0.3, 0.3, 0] },
        { text: "Q", at: 1, offset: [-0.3, 0.3, 0] },
      ],
    },
    {
      points: (() => {
        const angle1 = Math.PI / 6;
        return [
          { x: 0, y: 0, z: 0 },
          { x: 4 * Math.cos(angle1), y: 4 * Math.sin(angle1), z: 0 },
        ];
      })(),
      color: getColor("TEAL"),
      showPoints: false,
      smooth: false,
    },
    {
      points: (() => {
        const angle2 = (2 * Math.PI) / 3;
        return [
          { x: 0, y: 0, z: 0 },
          { x: 4 * Math.cos(angle2), y: 4 * Math.sin(angle2), z: 0 },
        ];
      })(),
      color: getColor("TEAL"),
      showPoints: false,
      smooth: false,
    },
    {
      points: (() => {
        const startAngle = Math.PI / 6;
        const endAngle = (2 * Math.PI) / 3;
        const numPoints = 20;
        return Array.from({ length: numPoints + 1 }, (_, i) => {
          const angle = startAngle + (endAngle - startAngle) * (i / numPoints);
          return {
            x: 1.5 * Math.cos(angle),
            y: 1.5 * Math.sin(angle),
            z: 0,
          };
        });
      })(),
      color: getColor("AMBER"),
      showPoints: false,
      labels: [{ text: "θ", at: 10, offset: [0, -0.5, 0] }],
    },
  ]}
  cameraPosition={[0, 0, 12]}
  showZAxis={false}
/>

### Distance of Chord from Center

The distance of a chord from the center of the circle can be calculated using the formula:

<BlockMath math="d = r \cos\left(\frac{\theta}{2}\right)" />

Or if the chord length <InlineMath math="l" /> is known:

<BlockMath math="d = \sqrt{r^2 - \left(\frac{l}{2}\right)^2}" />

## Intersecting Chords Theorem

If two chords intersect inside a circle, then the product of the segments of one chord equals the product of the segments of the other chord.

<LineEquation
  title="Intersection of Two Chords"
  description={
    <>
      Intersecting chords theorem: <InlineMath math="PA \times PB = PC \times PD" />.
    </>
  }
  data={[
    {
      points: Array.from({ length: 361 }, (_, i) => {
        const angle = (i * Math.PI) / 180;
        return {
          x: 5 * Math.cos(angle),
          y: 5 * Math.sin(angle),
          z: 0,
        };
      }),
      color: getColor("PURPLE"),
      showPoints: false,
    },
    {
      points: (() => {
        const angle1 = Math.PI / 3;
        const angle2 = (4 * Math.PI) / 3;
        return [
          { x: 5 * Math.cos(angle1), y: 5 * Math.sin(angle1), z: 0 },
          { x: 5 * Math.cos(angle2), y: 5 * Math.sin(angle2), z: 0 },
        ];
      })(),
      color: getColor("CYAN"),
      showPoints: true,
      labels: [
        { text: "A", at: 0, offset: [0.3, 0.3, 0] },
        { text: "B", at: 1, offset: [-0.3, -0.3, 0] },
      ],
    },
    {
      points: (() => {
        const angle1 = (5 * Math.PI) / 6;
        const angle2 = (11 * Math.PI) / 6;
        return [
          { x: 5 * Math.cos(angle1), y: 5 * Math.sin(angle1), z: 0 },
          { x: 5 * Math.cos(angle2), y: 5 * Math.sin(angle2), z: 0 },
        ];
      })(),
      color: getColor("TEAL"),
      showPoints: true,
      labels: [
        { text: "C", at: 0, offset: [-0.3, 0.3, 0] },
        { text: "D", at: 1, offset: [0.3, -0.3, 0] },
      ],
    },
    {
      points: (() => {
        // Calculate intersection point P
        const A = {
          x: 5 * Math.cos(Math.PI / 3),
          y: 5 * Math.sin(Math.PI / 3),
        };
        const B = {
          x: 5 * Math.cos((4 * Math.PI) / 3),
          y: 5 * Math.sin((4 * Math.PI) / 3),
        };
        const C = {
          x: 5 * Math.cos((5 * Math.PI) / 6),
          y: 5 * Math.sin((5 * Math.PI) / 6),
        };
        const D = {
          x: 5 * Math.cos((11 * Math.PI) / 6),
          y: 5 * Math.sin((11 * Math.PI) / 6),
        };

        // Line AB: parametric form
        // Line CD: parametric form
        // Solve for intersection
        const denominator =
          (A.x - B.x) * (C.y - D.y) - (A.y - B.y) * (C.x - D.x);
        const t =
          ((A.x - C.x) * (C.y - D.y) - (A.y - C.y) * (C.x - D.x)) / denominator;

        const P = {
          x: A.x + t * (B.x - A.x),
          y: A.y + t * (B.y - A.y),
        };

        return [{ x: P.x, y: P.y, z: 0 }];
      })(),
      color: getColor("PINK"),
      showPoints: true,
      labels: [{ text: "P", at: 0, offset: [0.3, 0, 0] }],
    },

]}
cameraPosition={[0, 0, 15]}
showZAxis={false}
/>

In the figure above, the following holds: <InlineMath math="PA \times PB = PC \times PD" />

## Inscribed Angles Subtending the Same Chord

Inscribed angles that subtend the same chord have equal measures.

<LineEquation
  title="Inscribed Angles Subtending the Same Chord"
  description="Inscribed angles subtending chord AB have equal measures."
  data={[
    {
      points: Array.from({ length: 361 }, (_, i) => {
        const angle = (i * Math.PI) / 180;
        return {
          x: 4 * Math.cos(angle),
          y: 4 * Math.sin(angle),
          z: 0,
        };
      }),
      color: getColor("PURPLE"),
      showPoints: false,
    },
    {
      points: (() => {
        const angleA = 0;
        const angleB = Math.PI / 2;
        return [
          { x: 4 * Math.cos(angleA), y: 4 * Math.sin(angleA), z: 0 },
          { x: 4 * Math.cos(angleB), y: 4 * Math.sin(angleB), z: 0 },
        ];
      })(),
      color: getColor("CYAN"),
      showPoints: true,
      labels: [
        { text: "A", at: 0, offset: [0.5, 0, 0] },
        { text: "B", at: 1, offset: [0, 0.5, 0] },
      ],
    },
    {
      points: (() => {
        const angleC = (3 * Math.PI) / 4;
        const angleA = 0;
        const angleB = Math.PI / 2;
        return [
          { x: 4 * Math.cos(angleC), y: 4 * Math.sin(angleC), z: 0 },
          { x: 4 * Math.cos(angleA), y: 4 * Math.sin(angleA), z: 0 },
          { x: 4 * Math.cos(angleB), y: 4 * Math.sin(angleB), z: 0 },
          { x: 4 * Math.cos(angleC), y: 4 * Math.sin(angleC), z: 0 },
        ];
      })(),
      color: getColor("PINK"),
      showPoints: true,
      smooth: false,
      labels: [{ text: "C", at: 0, offset: [-0.3, 0.3, 0] }],
    },
    {
      points: (() => {
        const angleD = (5 * Math.PI) / 4;
        const angleA = 0;
        const angleB = Math.PI / 2;
        return [
          { x: 4 * Math.cos(angleD), y: 4 * Math.sin(angleD), z: 0 },
          { x: 4 * Math.cos(angleA), y: 4 * Math.sin(angleA), z: 0 },
          { x: 4 * Math.cos(angleB), y: 4 * Math.sin(angleB), z: 0 },
          { x: 4 * Math.cos(angleD), y: 4 * Math.sin(angleD), z: 0 },
        ];
      })(),
      color: getColor("AMBER"),
      showPoints: true,
      smooth: false,
      labels: [{ text: "D", at: 0, offset: [-0.3, -0.3, 0] }],
    },
  ]}
  cameraPosition={[0, 0, 12]}
  showZAxis={false}
/>

In the figure above, <InlineMath math="\angle ACB = \angle ADB" /> because both subtend the same chord <InlineMath math="AB" />.

## Apothem

An apothem is the shortest distance from the center of a circle to a chord, which is the perpendicular line from the center to the chord.

<LineEquation
  title="Apothem of a Chord"
  description="Apothem is the perpendicular line from the center to the chord."
  data={[
    {
      points: Array.from({ length: 361 }, (_, i) => {
        const angle = (i * Math.PI) / 180;
        return {
          x: 5 * Math.cos(angle),
          y: 5 * Math.sin(angle),
          z: 0,
        };
      }),
      color: getColor("PURPLE"),
      showPoints: false,
    },
    {
      points: [{ x: 0, y: 0, z: 0 }],
      color: getColor("ORANGE"),
      showPoints: true,
      labels: [{ text: "O", at: 0, offset: [-0.3, -0.3, 0] }],
    },
    {
      points: (() => {
        const y = 3;
        const x = Math.sqrt(25 - y * y);
        return [
          { x: -x, y: y, z: 0 },
          { x: x, y: y, z: 0 },
        ];
      })(),
      color: getColor("CYAN"),
      showPoints: true,
      labels: [
        { text: "P", at: 0, offset: [-0.3, 0.3, 0] },
        { text: "Q", at: 1, offset: [0.3, 0.3, 0] },
      ],
    },
    {
      points: [
        { x: 0, y: 0, z: 0 },
        { x: 0, y: 3, z: 0 },
      ],
      color: getColor("PINK"),
      showPoints: true,
      smooth: false,
      labels: [
        { text: "M", at: 1, offset: [0.5, 0, 0] },
        { text: "apothem", at: 0.5, offset: [1.2, 0, 0] },
      ],
    },
    {
      points: [
        { x: -0.3, y: 3, z: 0 },
        { x: -0.3, y: 2.7, z: 0 },
        { x: 0, y: 2.7, z: 0 },
      ],
      color: getColor("AMBER"),
      showPoints: false,
      smooth: false,
    },
  ]}
  cameraPosition={[0, 0, 15]}
  showZAxis={false}
/>

The length of the apothem can be calculated using the formula:

<BlockMath math="a = r \cos\left(\frac{\theta}{2}\right) = \sqrt{r^2 - \left(\frac{l}{2}\right)^2}" />

Where:

- <InlineMath math="a" /> = length of apothem
- <InlineMath math="r" /> = radius of the circle
- <InlineMath math="l" /> = length of the chord
- <InlineMath math="\theta" /> = central angle

## Parallel Chords

Two parallel chords in a circle have special properties.

<LineEquation
  title="Parallel Chords"
  description="Arcs between parallel chords have equal lengths."
  data={[
    {
      points: Array.from({ length: 361 }, (_, i) => {
        const angle = (i * Math.PI) / 180;
        return {
          x: 4 * Math.cos(angle),
          y: 4 * Math.sin(angle),
          z: 0,
        };
      }),
      color: getColor("PURPLE"),
      showPoints: false,
    },
    {
      points: (() => {
        const y = 2;
        const x = Math.sqrt(16 - y * y);
        return [
          { x: -x, y: y, z: 0 },
          { x: x, y: y, z: 0 },
        ];
      })(),
      color: getColor("CYAN"),
      showPoints: true,
      labels: [
        { text: "A", at: 0, offset: [-0.3, 0.3, 0] },
        { text: "B", at: 1, offset: [0.3, 0.3, 0] },
      ],
    },
    {
      points: (() => {
        const y = -2;
        const x = Math.sqrt(16 - y * y);
        return [
          { x: -x, y: y, z: 0 },
          { x: x, y: y, z: 0 },
        ];
      })(),
      color: getColor("TEAL"),
      showPoints: true,
      labels: [
        { text: "C", at: 0, offset: [-0.3, -0.3, 0] },
        { text: "D", at: 1, offset: [0.3, -0.3, 0] },
      ],
    },
    {
      points: (() => {
        const y1 = 2;
        const x1 = Math.sqrt(16 - y1 * y1);
        const angle1 = Math.atan2(y1, -x1);
        const y2 = -2;
        const x2 = Math.sqrt(16 - y2 * y2);
        const angle2 = Math.atan2(y2, -x2);
        const numPoints = 20;
        return Array.from({ length: numPoints + 1 }, (_, i) => {
          const angle = angle1 + (angle2 - angle1) * (i / numPoints);
          return {
            x: 4 * Math.cos(angle),
            y: 4 * Math.sin(angle),
            z: 0,
          };
        });
      })(),
      color: getColor("PINK"),
      showPoints: false,
    },
    {
      points: (() => {
        const y1 = 2;
        const x1 = Math.sqrt(16 - y1 * y1);
        const angle1 = Math.atan2(y1, x1);
        const y2 = -2;
        const x2 = Math.sqrt(16 - y2 * y2);
        const angle2 = Math.atan2(y2, x2);
        const numPoints = 20;
        return Array.from({ length: numPoints + 1 }, (_, i) => {
          const angle = angle1 + (angle2 - angle1) * (i / numPoints);
          return {
            x: 4 * Math.cos(angle),
            y: 4 * Math.sin(angle),
            z: 0,
          };
        });
      })(),
      color: getColor("AMBER"),
      showPoints: false,
    },
  ]}
  cameraPosition={[0, 0, 12]}
  showZAxis={false}
/>

If <InlineMath math="AB \parallel CD" />, then arc <InlineMath math="AC" /> equals arc <InlineMath math="BD" />.

## Practice Problems

1. A circle has a radius of 10 cm. If the central angle subtending a chord is 60°, determine:

   - The length of the chord
   - The distance of the chord from the center of the circle

2. Two chords <InlineMath math="AB" /> and <InlineMath math="CD" /> intersect at point <InlineMath math="P" /> inside a circle. If <InlineMath math="PA = 4" /> cm, <InlineMath math="PB = 6" /> cm, and <InlineMath math="PC = 3" /> cm, find the length of <InlineMath math="PD" />.

3. In a circle with radius 13 cm, there is a chord of length 24 cm. Calculate the distance of this chord from the center of the circle.

4. Two parallel chords in a circle are 3 cm and 4 cm away from the center respectively. If the radius of the circle is 5 cm, determine the lengths of both chords.

5. Prove that the longest chord in a circle is the diameter.

### Answer Key

1. **Calculating chord length and its distance from center**

   Given: <InlineMath math="r = 10" /> cm, <InlineMath math="\theta = 60° = \frac{\pi}{3}" /> rad

   <div className="flex flex-col gap-4">
     <BlockMath math="l = 2r \sin\left(\frac{\theta}{2}\right) = 2 \times 10 \times \sin\left(\frac{\pi/3}{2}\right)" />
     <BlockMath math="l = 20 \times \sin(30°) = 20 \times 0.5 = 10 \text{ cm}" />
     <BlockMath math="d = r \cos\left(\frac{\theta}{2}\right) = 10 \times \cos(30°)" />
     <BlockMath math="d = 10 \times \frac{\sqrt{3}}{2} = 5\sqrt{3} \text{ cm}" />
   </div>

2. **Intersecting chords theorem**

   Given: <InlineMath math="PA = 4" /> cm, <InlineMath math="PB = 6" /> cm, <InlineMath math="PC = 3" /> cm

   <div className="flex flex-col gap-4">
     <BlockMath math="PA \times PB = PC \times PD" />
     <BlockMath math="4 \times 6 = 3 \times PD" />
     <BlockMath math="24 = 3 \times PD" />
     <BlockMath math="PD = 8 \text{ cm}" />
   </div>

3. **Calculating distance of chord from center**

   Given: <InlineMath math="r = 13" /> cm, <InlineMath math="l = 24" /> cm

   <div className="flex flex-col gap-4">
     <BlockMath math="d = \sqrt{r^2 - \left(\frac{l}{2}\right)^2}" />
     <BlockMath math="d = \sqrt{13^2 - 12^2}" />
     <BlockMath math="d = \sqrt{169 - 144}" />
     <BlockMath math="d = \sqrt{25} = 5 \text{ cm}" />
   </div>

4. **Parallel chords**

   Given: <InlineMath math="r = 5" /> cm, <InlineMath math="d_1 = 3" /> cm, <InlineMath math="d_2 = 4" /> cm

   For the first chord:

   <div className="flex flex-col gap-4">
     <BlockMath math="l_1 = 2\sqrt{r^2 - d_1^2} = 2\sqrt{25 - 9} = 2\sqrt{16} = 8 \text{ cm}" />
   </div>

   For the second chord:

   <div className="flex flex-col gap-4">
     <BlockMath math="l_2 = 2\sqrt{r^2 - d_2^2} = 2\sqrt{25 - 16} = 2\sqrt{9} = 6 \text{ cm}" />
   </div>

5. **Proof that diameter is the longest chord**

   For any chord with central angle <InlineMath math="\theta" />:

   <div className="flex flex-col gap-4">
     <BlockMath math="l = 2r \sin\left(\frac{\theta}{2}\right)" />
   </div>

   The maximum value of <InlineMath math="\sin\left(\frac{\theta}{2}\right) = 1" /> is achieved when <InlineMath math="\frac{\theta}{2} = 90°" />, that is <InlineMath math="\theta = 180°" />.

   When <InlineMath math="\theta = 180°" />, the chord passes through the center of the circle (diameter) with length:

   <div className="flex flex-col gap-4">
     <BlockMath math="l_{max} = 2r \times 1 = 2r" />
   </div>

   Therefore, the diameter is the longest chord.