chứng minh đường trung bình song song với cạnh đáy

การพิสูจน์เส้นตรงขนานกับฐาน — ทฤษฎีเส้นกึ่งกลางสามเหลี่ยม

ทฤษฎีเส้นกึ่งกลางสามเหลี่ยม (Midsegment Theorem) เป็นทฤษฎีบทสำคัญในเรขาคณิตที่ระบุว่า เส้นที่ลากเชื่อมจุดกึ่งกลางของด้านสองด้านของสามเหลี่ยม จะขนานกับด้านที่สาม (ฐาน) และมีความยาวเท่ากับครึ่งหนึ่งของด้านฐาน บทความนี้อธิบายการพิสูจน์ทั้งแบบ Euclidean geometry และ coordinate geometry พร้อม Python code สำหรับตรวจสอบและ visualize ทฤษฎีบท รวมถึงการประยุกต์ใช้ในงาน computational geometry และ computer graphics

ทฤษฎีเส้นกึ่งกลางสามเหลี่ยม

# midsegment.py — Midsegment Theorem
import json

class MidsegmentTheorem:
    THEOREM = {
        "name": "Midsegment Theorem (ทฤษฎีเส้นกึ่งกลาง)",
        "statement": "ถ้า M เป็นจุดกึ่งกลางของ AB และ N เป็นจุดกึ่งกลางของ AC แล้ว MN // BC และ MN = BC/2",
        "conditions": "M = midpoint(A, B), N = midpoint(A, C)",
        "conclusions": ["MN ขนานกับ BC (MN // BC)", "MN = BC / 2"],
    }

    PROOF_EUCLIDEAN = """
    การพิสูจน์แบบ Euclidean:
    
    กำหนดให้ สามเหลี่ยม ABC
    M = จุดกึ่งกลางของ AB
    N = จุดกึ่งกลางของ AC
    
    พิสูจน์: MN // BC และ MN = BC/2
    
    วิธีที่ 1: ใช้สามเหลี่ยมคล้าย (Similar Triangles)
    
    1. เนื่องจาก AM/AB = AN/AC = 1/2
    2. และมุม A เป็นมุมร่วม (∠MAN = ∠BAC)
    3. ดังนั้น △AMN ~ △ABC (SAS Similarity)
    4. อัตราส่วนคล้าย = 1/2
    5. จาก similarity: ∠AMN = ∠ABC
    6. เนื่องจาก ∠AMN = ∠ABC (corresponding angles)
       และ MN ตัดกับ AB (transversal)
    7. ดังนั้น MN // BC (เส้นตรงสองเส้นทำมุม
       corresponding angles เท่ากัน = ขนาน)
    8. จาก similarity ratio: MN/BC = 1/2
       ดังนั้น MN = BC/2  ∎
    """

    PROOF_COORDINATE = """
    การพิสูจน์แบบ Coordinate Geometry:
    
    กำหนดจุด: A(x1, y1), B(x2, y2), C(x3, y3)
    
    M = midpoint(A, B) = ((x1+x2)/2, (y1+y2)/2)
    N = midpoint(A, C) = ((x1+x3)/2, (y1+y3)/2)
    
    พิสูจน์ MN // BC:
    
    slope(MN) = (yN - yM) / (xN - xM)
             = ((y1+y3)/2 - (y1+y2)/2) / ((x1+x3)/2 - (x1+x2)/2)
             = (y3 - y2) / (x3 - x2)
    
    slope(BC) = (y3 - y2) / (x3 - x2)
    
    slope(MN) = slope(BC)  →  MN // BC  ∎
    
    พิสูจน์ MN = BC/2:
    
    |MN| = sqrt((xN-xM)² + (yN-yM)²)
         = sqrt(((x3-x2)/2)² + ((y3-y2)/2)²)
         = (1/2) × sqrt((x3-x2)² + (y3-y2)²)
         = (1/2) × |BC|  ∎
    """

    def show_theorem(self):
        print("=== Midsegment Theorem ===\n")
        print(f"  {self.THEOREM['statement']}")
        for c in self.THEOREM['conclusions']:
            print(f"  → {c}")

    def show_euclidean(self):
        print(f"\n=== Euclidean Proof ===")
        print(self.PROOF_EUCLIDEAN[:500])

    def show_coordinate(self):
        print(f"\n=== Coordinate Proof ===")
        print(self.PROOF_COORDINATE[:500])

thm = MidsegmentTheorem()
thm.show_theorem()
thm.show_euclidean()
thm.show_coordinate()

Python Verification

# verify.py — Python verification of Midsegment Theorem
import json
import math
import random

class MidsegmentVerification:
    def midpoint(self, p1, p2):
        return ((p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2)
    
    def distance(self, p1, p2):
        return math.sqrt((p2[0] - p1[0])**2 + (p2[1] - p1[1])**2)
    
    def slope(self, p1, p2):
        dx = p2[0] - p1[0]
        if abs(dx) < 1e-10:
            return float('inf')
        return (p2[1] - p1[1]) / dx
    
    def is_parallel(self, p1, p2, p3, p4, tol=1e-9):
        s1 = self.slope(p1, p2)
        s2 = self.slope(p3, p4)
        if s1 == float('inf') and s2 == float('inf'):
            return True
        return abs(s1 - s2) < tol
    
    def verify_theorem(self, A, B, C):
        M = self.midpoint(A, B)
        N = self.midpoint(A, C)
        
        parallel = self.is_parallel(M, N, B, C)
        mn_length = self.distance(M, N)
        bc_length = self.distance(B, C)
        half_check = abs(mn_length - bc_length / 2) < 1e-9
        
        return {
            "A": A, "B": B, "C": C,
            "M (midpoint AB)": M,
            "N (midpoint AC)": N,
            "MN // BC": parallel,
            "MN = BC/2": half_check,
            "|MN|": round(mn_length, 4),
            "|BC|": round(bc_length, 4),
            "|BC|/2": round(bc_length / 2, 4),
        }
    
    def random_test(self, n=5):
        print("=== Random Triangle Verification ===\n")
        for i in range(n):
            A = (random.uniform(-10, 10), random.uniform(-10, 10))
            B = (random.uniform(-10, 10), random.uniform(-10, 10))
            C = (random.uniform(-10, 10), random.uniform(-10, 10))
            
            result = self.verify_theorem(A, B, C)
            status = "PASS" if result["MN // BC"] and result["MN = BC/2"] else "FAIL"
            print(f"  Test {i+1}: [{status}] |MN|={result['|MN|']} = |BC|/2={result['|BC|/2|']}" if '|BC|/2|' in result else f"  Test {i+1}: [{status}] |MN|={result['|MN|']} = |BC|/2={result['|BC|/2']}")
        print(f"\n  All tests should PASS — theorem holds for any triangle")

verify = MidsegmentVerification()
result = verify.verify_theorem((0, 0), (6, 0), (3, 8))
print("=== Specific Example ===")
print(f"  Triangle: A(0,0) B(6,0) C(3,8)")
print(f"  M(midpoint AB) = {result['M (midpoint AB)']}")
print(f"  N(midpoint AC) = {result['N (midpoint AC)']}")
print(f"  MN // BC: {result['MN // BC']}")
print(f"  MN = BC/2: {result['MN = BC/2']}")
print(f"  |MN| = {result['|MN|']}, |BC|/2 = {result['|BC|/2']}")

Visualization

# visualize.py — Matplotlib visualization
import json

class MidsegmentVisualization:
    CODE = """
# plot_midsegment.py — Visualize Midsegment Theorem
import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
import numpy as np

def plot_midsegment(A, B, C):
    M = ((A[0]+B[0])/2, (A[1]+B[1])/2)
    N = ((A[0]+C[0])/2, (A[1]+C[1])/2)
    
    fig, ax = plt.subplots(1, 1, figsize=(8, 6))
    
    # Draw triangle
    triangle = plt.Polygon([A, B, C], fill=False, edgecolor='blue', linewidth=2)
    ax.add_patch(triangle)
    
    # Draw midsegment MN
    ax.plot([M[0], N[0]], [M[1], N[1]], 'r-', linewidth=2, label='MN (midsegment)')
    
    # Draw base BC
    ax.plot([B[0], C[0]], [B[1], C[1]], 'b-', linewidth=2, label='BC (base)')
    
    # Mark points
    for point, label in [(A, 'A'), (B, 'B'), (C, 'C'), (M, 'M'), (N, 'N')]:
        ax.plot(*point, 'ko', markersize=8)
        ax.annotate(label, point, textcoords="offset points", 
                   xytext=(10, 10), fontsize=14, fontweight='bold')
    
    # Add parallel markers
    ax.annotate('MN // BC', xy=(0.5, 0.95), xycoords='axes fraction',
               fontsize=12, ha='center', color='red')
    
    mn_len = np.sqrt((N[0]-M[0])**2 + (N[1]-M[1])**2)
    bc_len = np.sqrt((C[0]-B[0])**2 + (C[1]-B[1])**2)
    ax.annotate(f'|MN| = {mn_len:.2f} = |BC|/2 = {bc_len/2:.2f}',
               xy=(0.5, 0.9), xycoords='axes fraction', fontsize=11, ha='center')
    
    ax.set_aspect('equal')
    ax.legend()
    ax.set_title('Midsegment Theorem: MN // BC, MN = BC/2')
    ax.grid(True, alpha=0.3)
    plt.tight_layout()
    plt.savefig('midsegment.png', dpi=150)
    plt.show()

plot_midsegment((0, 0), (8, 0), (3, 6))
"""

    def show_code(self):
        print("=== Matplotlib Visualization ===")
        print(self.CODE[:600])

    def ascii_visualization(self):
        print(f"\n=== ASCII Visualization ===")
        print("""
              A
             /\\
            /  \\
           /    \\
       M  /------\\  N     ← MN (midsegment)
         /   //   \\
        /   //     \\
       /   //       \\
      B--------------C     ← BC (base)
      
      MN // BC  (ขนาน)
      |MN| = |BC| / 2
        """)

vis = MidsegmentVisualization()
vis.show_code()
vis.ascii_visualization()

ทฤษฎีบทที่เกี่ยวข้อง

# related.py — Related theorems
import json

class RelatedTheorems:
    THEOREMS = {
        "basic_proportionality": {
            "name": "Basic Proportionality Theorem (Thales)",
            "statement": "ถ้าเส้นตรงขนานกับด้านหนึ่งของสามเหลี่ยม ตัดด้านอีกสองด้าน จะแบ่งด้านทั้งสองในอัตราส่วนเท่ากัน",
            "formula": "DE // BC → AD/DB = AE/EC",
        },
        "converse_bpt": {
            "name": "Converse of BPT",
            "statement": "ถ้าเส้นตรงแบ่งด้านสองด้านของสามเหลี่ยมในอัตราส่วนเท่ากัน แล้วเส้นนั้นขนานกับด้านที่สาม",
            "formula": "AD/DB = AE/EC → DE // BC",
        },
        "similar_triangles": {
            "name": "Similar Triangles (สามเหลี่ยมคล้าย)",
            "statement": "สามเหลี่ยมสองรูปที่มีมุมเท่ากัน 2 คู่ จะคล้ายกัน",
            "criteria": ["AA (Angle-Angle)", "SAS (Side-Angle-Side ratio)", "SSS (Side-Side-Side ratio)"],
        },
        "triangle_inequality": {
            "name": "Triangle Inequality",
            "statement": "ผลบวกของด้านสองด้านใดๆ ของสามเหลี่ยม ต้องมากกว่าด้านที่เหลือ",
            "formula": "a + b > c, b + c > a, a + c > b",
        },
    }

    APPLICATIONS = {
        "cg": {
            "name": "Computational Geometry",
            "use": "Mesh subdivision, Level of Detail (LOD), triangle mesh simplification",
        },
        "cad": {
            "name": "CAD/Engineering",
            "use": "Structural analysis, parallel beam verification, truss design",
        },
        "graphics": {
            "name": "Computer Graphics",
            "use": "Texture mapping, polygon clipping, barycentric coordinates",
        },
        "robotics": {
            "name": "Robotics/Navigation",
            "use": "Path planning, parallel trajectory verification, obstacle avoidance",
        },
    }

    def show_theorems(self):
        print("=== Related Theorems ===\n")
        for key, thm in self.THEOREMS.items():
            print(f"[{thm['name']}]")
            print(f"  {thm['statement']}")
            print()

    def show_applications(self):
        print("=== Applications ===")
        for key, app in self.APPLICATIONS.items():
            print(f"  [{app['name']}] {app['use']}")

related = RelatedTheorems()
related.show_theorems()
related.show_applications()

Computational Geometry Library

# geometry_lib.py — Computational geometry library
import json
import math

class GeometryLib:
    CODE = """
# triangle_lib.py — Triangle geometry library
import math

class Triangle:
    def __init__(self, A, B, C):
        self.A = A
        self.B = B
        self.C = C
    
    def midpoint(self, p1, p2):
        return ((p1[0]+p2[0])/2, (p1[1]+p2[1])/2)
    
    def distance(self, p1, p2):
        return math.sqrt((p2[0]-p1[0])**2 + (p2[1]-p1[1])**2)
    
    def area(self):
        # Shoelace formula
        x1, y1 = self.A
        x2, y2 = self.B
        x3, y3 = self.C
        return abs((x1*(y2-y3) + x2*(y3-y1) + x3*(y1-y2)) / 2)
    
    def perimeter(self):
        return (self.distance(self.A, self.B) + 
                self.distance(self.B, self.C) + 
                self.distance(self.A, self.C))
    
    def centroid(self):
        return ((self.A[0]+self.B[0]+self.C[0])/3,
                (self.A[1]+self.B[1]+self.C[1])/3)
    
    def midsegments(self):
        M_AB = self.midpoint(self.A, self.B)
        M_BC = self.midpoint(self.B, self.C)
        M_AC = self.midpoint(self.A, self.C)
        return {
            "MN (AB-AC midpoints)": (M_AB, M_AC),  # parallel to BC
            "MP (AB-BC midpoints)": (M_AB, M_BC),  # parallel to AC
            "NP (AC-BC midpoints)": (M_AC, M_BC),  # parallel to AB
        }
    
    def medial_triangle(self):
        M_AB = self.midpoint(self.A, self.B)
        M_BC = self.midpoint(self.B, self.C)
        M_AC = self.midpoint(self.A, self.C)
        return Triangle(M_AB, M_BC, M_AC)

# Usage
t = Triangle((0, 0), (8, 0), (4, 6))
print(f"Area: {t.area()}")
print(f"Perimeter: {t.perimeter():.2f}")
print(f"Centroid: {t.centroid()}")
medial = t.medial_triangle()
print(f"Medial triangle area: {medial.area()} = original/4: {t.area()/4}")
"""

    def show_code(self):
        print("=== Triangle Geometry Library ===")
        print(self.CODE[:600])

    def demo(self):
        print(f"\n=== Demo ===")
        A, B, C = (0, 0), (8, 0), (4, 6)
        area = abs((A[0]*(B[1]-C[1]) + B[0]*(C[1]-A[1]) + C[0]*(A[1]-B[1])) / 2)
        M_AB = ((A[0]+B[0])/2, (A[1]+B[1])/2)
        M_AC = ((A[0]+C[0])/2, (A[1]+C[1])/2)
        mn = math.sqrt((M_AC[0]-M_AB[0])**2 + (M_AC[1]-M_AB[1])**2)
        bc = math.sqrt((C[0]-B[0])**2 + (C[1]-B[1])**2)
        print(f"  Triangle A(0,0) B(8,0) C(4,6)")
        print(f"  Area = {area}")
        print(f"  M(midpoint AB) = {M_AB}")
        print(f"  N(midpoint AC) = {M_AC}")
        print(f"  |MN| = {mn:.4f}")
        print(f"  |BC|/2 = {bc/2:.4f}")
        print(f"  MN = BC/2: {abs(mn - bc/2) < 1e-9}")

lib = GeometryLib()
lib.show_code()
lib.demo()

FAQ - คำถามที่พบบ่อย

Q: ทฤษฎีเส้นกึ่งกลาง (Midsegment Theorem) คืออะไร?

A: เส้นที่ลากเชื่อมจุดกึ่งกลางของด้านสองด้านของสามเหลี่ยม จะขนานกับด้านที่สาม (ฐาน) และมีความยาวเท่ากับครึ่งหนึ่งของฐาน ใช้ได้กับสามเหลี่ยมทุกรูป ไม่ว่าจะเป็นสามเหลี่ยมด้านเท่า ด้านไม่เท่า หรือมุมฉาก

Q: พิสูจน์ได้กี่วิธี?

A: หลายวิธี: 1) สามเหลี่ยมคล้าย (Similar Triangles) — ง่ายที่สุด ใช้ SAS similarity 2) Coordinate Geometry — ใช้สูตร midpoint + slope 3) Vector Proof — ใช้ vector addition 4) Transformation — ใช้ dilation จาก A ด้วย scale 1/2 แต่ละวิธีให้ข้อมูลเชิงลึกต่างกัน

Q: Midsegment ใช้ทำอะไรในโปรแกรม?

A: Computational Geometry: mesh subdivision, triangle mesh simplification Computer Graphics: LOD (Level of Detail) — ลด polygon count โดยใช้ midsegments CAD: structural analysis, parallel beam verification Game Development: collision detection optimization, terrain generation Robotics: path planning, trajectory analysis

Q: Medial Triangle คืออะไร?

A: Medial Triangle เกิดจากการเชื่อมจุดกึ่งกลางทั้ง 3 ด้านของสามเหลี่ยม คุณสมบัติ: 1) มี 4 สามเหลี่ยมย่อยที่ congruent กัน 2) พื้นที่ medial triangle = 1/4 ของสามเหลี่ยมเดิม 3) ด้านทุกด้านของ medial triangle ขนานกับด้านของสามเหลี่ยมเดิม