Generate WORKING Manim code for Scene 1.

IMPLEMENTATION: ```python
from manim import *

class LinearSearchConcept(Scene):
    def construct(self):
        # Layout Plan:
        # 1. Title: Text - .to_edge(UP, buff=0.5) - Scene title
        # 2. Main equation: Text - .shift(UP * 1.5) - Definition of linear search
        # 3. Secondary text: Text - .shift(DOWN * 1.5) - Explanation when/why used
        # 4. Left elements: Diagram of list with highlighted target - .shift(LEFT * 2.5)
        # 5. Right elements: Step progression text - .shift(RIGHT * 2.5)
        
        # --- Element 1: Title ---
        title = Text("Linear Search Algorithm", color=BLUE).to_edge(UP, buff=0.5)
        
        # --- Element 2: Main equation (definition) ---
        main_eq = Text(
            "Linear search checks each element sequentially\n"
            "from start to end to find a target value.",
            color=WHITE
        ).shift(UP * 1.5)
        
        # --- Element 3: Secondary text (when/why used) ---
        secondary_text = Text(
            "Used especially in unsorted lists\n"
            "when no faster search method applies.",
            color=YELLOW
        ).shift(DOWN * 1.5)
        
        # --- Left element: Diagram of list with highlighted target ---
        # Represent list as rectangles with numbers inside, highlight target with RED rectangle
        
        # Create 7 elements in a horizontal row
        elements = VGroup()
        values = ["3", "8", "1", "7", "5", "2", "9"]
        for i, val in enumerate(values):
            rect = Rectangle(width=0.8, height=1, stroke_color=WHITE)
            num = Text(val, color=WHITE).scale(0.7)
            group = VGroup(rect, num)
            group.arrange(DOWN, buff=0.1)
            group.shift(RIGHT * i * 0.9)
            elements.add(group)
        
        elements.shift(LEFT * 2.5)
        
        # Highlight target element (value "7" at index 3)
        target_rect = SurroundingRectangle(elements[3][0], color=RED, buff=0.1)
        
        # --- Right element: Step progression text ---
        step_text = Text(
            "Step 1: Check first element\n"
            "Step 2: Check next element\n"
            "...\n"
            "Step n: Find target or reach end",
            color=GREEN
        ).shift(RIGHT * 2.5)
        
        # --- Animation Sequence ---
        
        # 1. Show title and main equation and secondary text
        self.play(Write(title), Write(main_eq), Write(secondary_text), run_time=3)
        self.wait(1)
        
        # 2. Fade out secondary text, keep title and main_eq
        self.play(FadeOut(secondary_text), run_time=1)
        
        # 3. Show left diagram and highlight target, show right step progression
        self.play(Create(elements), Create(target_rect), Write(step_text), run_time=3)
        self.wait(2)
        
        # 4. Fade out highlights and right text, keep title and main_eq
        self.play(FadeOut(target_rect), FadeOut(step_text), run_time=1)
        self.wait(1)
        
        # 5. Transition text (secondary text replacement)
        transition_text = Text(
            "Now that we know what linear search is,\n"
            "let's explore how the algorithm works step-by-step.",
            color=YELLOW
        ).shift(DOWN * 1.5)
        
        self.play(Write(transition_text), run_time=2)
        self.wait(2)
        
        # Final cleanup: fade out diagram and transition text, keep title and main_eq
        self.play(FadeOut(elements), FadeOut(transition_text), run_time=1)
        self.wait(1)
```
---

### Explanation:

- **Title**: "Linear Search Algorithm" in BLUE, positioned at top edge `.to_edge(UP, buff=0.5)`
- **Main equation**: Text definition of linear search, shifted up `.shift(UP * 1.5)`
- **Secondary text**: Explanation of usage, shifted down `.shift(DOWN * 1.5)`
- **Left elements**: Rectangles representing list elements, shifted left `.shift(LEFT * 2.5)`, with the target element highlighted by a red `SurroundingRectangle`
- **Right elements**: Step progression text, shifted right `.shift(RIGHT * 2.5)`
- **Animations**: Use only `Write`, `Create`, `FadeIn`, `FadeOut` as required
- **Colors**: Only BLUE, RED, GREEN, YELLOW, WHITE used
- **Positioning**: All shifts within +/-3 units, elements fit within screen bounds
- **Cleanup**: Fade out highlights and old descriptions as specified, keep main equation and title visible except final cleanup

This plan strictly follows the 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