Generate WORKING Manim code for Scene 1.

IMPLEMENTATION: ```python
from manim import *

class LinearSearchScene(Scene):
    def construct(self):
        # Layout Plan:
        # 1. Title: Text - .to_edge(UP, buff=0.5) - Scene title
        # 2. Diagram: Rectangle + Circles + Highlight (Circle) - .shift(LEFT * 2.5) - Visual focus: unsorted list with target highlighted
        # 3. Secondary Text: Text - .shift(DOWN * 1.5) - Explanation of linear search
        
        # Title
        title = Text("Understanding Linear Search").to_edge(UP, buff=0.5).set_color(WHITE)
        
        # Diagram of unsorted list with highlighted target element
        # Create a horizontal rectangle as container for list
        list_rect = Rectangle(width=6, height=1).shift(LEFT * 2.5)
        # Create 7 elements as circles with numbers inside
        elements = VGroup()
        values = [7, 2, 9, 4, 5, 1, 3]
        for i, val in enumerate(values):
            circle = Circle(radius=0.3, color=WHITE)
            number = Text(str(val), font_size=24).move_to(circle.get_center())
            group = VGroup(circle, number)
            group.shift(LEFT * 2.5 + RIGHT * (i * 0.9))
            elements.add(group)
        # Highlight target element (e.g. value 4 at index 3)
        target_index = 3
        highlight = Circle(radius=0.4, color=YELLOW)
        highlight.move_to(elements[target_index].get_center())
        
        # Secondary text: explanation
        explanation = Text(
            "Linear search checks each element sequentially to find a target.\n"
            "Works on sorted or unsorted lists but inefficient for large data.",
            font_size=24,
            t2c={"Linear search": BLUE, "target": YELLOW}
        ).shift(DOWN * 1.5).set_color(WHITE)
        
        # Main equation (algorithm description) - placed upper center
        main_eq = Text("Linear Search Algorithm", font_size=28).shift(UP * 1.5).set_color(GREEN)
        
        # Animation Sequence:
        # 1. Write title
        self.play(Write(title), run_time=1.5)
        
        # 2. Show diagram with highlight and explanation
        self.play(Create(list_rect), run_time=1)
        self.play(*[Create(el[0]) for el in elements], *[Write(el[1]) for el in elements], run_time=2)
        self.play(Create(highlight), run_time=1)
        self.play(Write(explanation), run_time=3)
        # Fade out highlight and explanation, keep title and list visible
        self.wait(1)
        self.play(FadeOut(highlight), FadeOut(explanation), run_time=1)
        
        # 3. Show main equation (algorithm title) and secondary text for transition
        self.play(Write(main_eq), run_time=1.5)
        transition_text = Text(
            "Now that we know what linear search is,\nlet's explore how the algorithm works step-by-step.",
            font_size=24,
            t2c={"linear search": BLUE}
        ).shift(DOWN * 1.5).set_color(WHITE)
        self.play(Write(transition_text), run_time=2)
        # Fade out transition text, keep title and main_eq visible, fade out list and rectangle
        self.wait(1)
        self.play(FadeOut(transition_text), FadeOut(list_rect), *[FadeOut(el) for el in elements], FadeOut(title), run_time=1.5)
        
        # 4. Final cleanup: keep main_eq visible for next scene or end
        self.wait(1)
```
---

### Explanation:

- **Title** is positioned `.to_edge(UP, buff=0.5)` as required.
- **Diagram** (list rectangle + circles) is shifted `.shift(LEFT * 2.5)`.
- **Main equation** (algorithm title) is `.shift(UP * 1.5)`.
- **Secondary texts** (explanation and transition) are `.shift(DOWN * 1.5)`.
- Colors used only from the allowed set: WHITE, YELLOW, BLUE, GREEN.
- Animations are only `Write`, `Create`, and `FadeOut`.
- No elements shifted beyond +/-3 in any direction.
- Cleanup rules followed: highlights and old texts fade out before new ones; main equation remains visible at the end.
- Kept layout simple and readable within screen bounds (-6 to +6 horizontal, -3.5 to +3.5 vertical).

This plan strictly respects all instructions and positioning rules.
PATTERN: step_progression

CRITICAL CONSTRAINTS:
1. Use ONLY these objects: Text, MathTex, Axes, Circle, Rectangle, Line, Arrow, Dot, SurroundingRectangle, VGroup
2. Use ONLY these animations: Write, Create, FadeIn, FadeOut 
3. Use ONLY these colors (no quotes): BLUE, RED, GREEN, YELLOW, WHITE, ORANGE, PURPLE
4. NO undefined objects like VideoFile, Slider, ImageMobject
5. NO Unicode characters - use LaTeX: \sqrt{} not √, \pm not ±

POSITIONING REQUIREMENTS (CRITICAL):
- Each element MUST have unique position within screen bounds
- SAFE positions only: .to_edge(UP), .shift(UP*1.5), .shift(DOWN*1.5), .shift(LEFT*2.5), .shift(RIGHT*2.5)
- NO extreme shifts: avoid UP*3, DOWN*3, LEFT*4, RIGHT*4 (goes off-screen)
- NO overlapping: if one element uses .shift(UP*1.5), others must use different positions
- Test positions: Title=top, Main=upper center, Secondary=lower center, Sides=left/right

TEMPLATE TO ADAPT:

        # Title at top
        title = Text("{title}").scale(0.8).to_edge(UP, buff=0.5)
        
        # Step equations positioned vertically
        step1 = MathTex(r"{step1}").shift(UP * 2)
        step2 = MathTex(r"{step2}").shift(UP * 0.5)  
        step3 = MathTex(r"{step3}").shift(DOWN * 1)
        
        # Step labels on the right
        label1 = Text("{label1}").scale(0.5).shift(RIGHT * 4 + UP * 2)
        label2 = Text("{label2}").scale(0.5).shift(RIGHT * 4 + UP * 0.5)
        label3 = Text("{label3}").scale(0.5).shift(RIGHT * 4 + DOWN * 1)
        
        # Progressive revelation
        self.play(Write(title))
        self.wait(1)
        self.play(Write(step1))
        self.wait(1)
        self.play(Write(label1))
        self.wait(1)
        self.play(Write(step2))
        self.wait(1)
        self.play(Write(label2))
        self.wait(1)
        self.play(Write(step3))
        self.wait(1)
        self.play(Write(label3))
        self.wait(2)
                

Replace placeholders with scene-specific values and ensure working Manim code.

Generate complete Python code:
SMART POSITIONING REQUIREMENTS:
- Analyze the content TYPE first: equation, diagram, comparison, process
- Position based on content meaning, not just arbitrary rules
- Main subject (equation/diagram) should be CENTER or slightly UP
- Supporting text should be BELOW the main subject
- Comparisons should use LEFT/RIGHT positioning
- Sequential content should use TOP-to-BOTTOM flow
- NEVER fade out main content - only temporary highlights

CAREFULLY IMPLEMENT THIS