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
        title = Text("Linear Search Algorithm").to_edge(UP, buff=0.5)
        
        # 2. Main equation: MathTex - .shift(UP * 1.5) - Illustrate unordered list with highlighted target
        # Represent list as a sequence of numbers inside rectangles, highlight target with SurroundingRectangle in RED
        # We'll show: [7, 2, 9, 4, 5] with target=4 highlighted
        numbers = [7, 2, 9, 4, 5]
        rects = VGroup()
        nums_text = VGroup()
        for i, num in enumerate(numbers):
            rect = Rectangle(width=1, height=1, stroke_color=WHITE)
            rect.shift(RIGHT * (i - 2) * 1.2)  # center list around 0, spacing 1.2
            rects.add(rect)
            num_text = MathTex(str(num), color=WHITE).move_to(rect.get_center())
            nums_text.add(num_text)
        # Highlight target value 4 (index 3)
        target_index = 3
        target_highlight = SurroundingRectangle(rects[target_index], color=RED, buff=0.1)
        list_group = VGroup(rects, nums_text, target_highlight).shift(UP * 1.5)
        
        # 3. Secondary text: Text - .shift(DOWN * 1.5) - Explanation of linear search concept
        explanation = Text(
            "Linear search checks each element sequentially\n"
            "to find if the target value exists in the list.",
            color=WHITE
        ).shift(DOWN * 1.5)
        
        # Animation Sequence:
        # 1. Write title (duration 2s), no cleanup yet
        self.play(Write(title), run_time=2)
        
        # 2. Create list with highlighted target (duration 3s), keep title, fade out old if any (none)
        self.play(Create(rects), Write(nums_text), Create(target_highlight), run_time=3)
        
        # 3. Write explanation text (duration 3s), keep title and list, no fadeout of main yet
        self.play(Write(explanation), run_time=3)
        
        # Pause briefly
        self.wait(1)
        
        # 4. Transition: fade out explanation and highlight (duration 2s), keep title and list visible
        self.play(FadeOut(explanation), FadeOut(target_highlight), run_time=2)
        
        # End scene with title and list visible, ready for next scene's step-by-step process
        self.wait(1)
```
---

**Explanation:**

- Title is positioned `.to_edge(UP, buff=0.5)` (top edge).
- The list (main equation) is centered and shifted `UP * 1.5`.
- The explanation text is shifted `DOWN * 1.5`.
- The list elements are arranged horizontally with a small spacing, centered around 0.
- The target element is highlighted with a red `SurroundingRectangle`.
- Animations use only `Write`, `Create`, and `FadeOut`.
- Colors limited to WHITE and RED (highlight).
- Cleanup fades out explanation and highlight but keeps the title and list visible.
- No shifts beyond +/-3 units.
- Layout fits within screen bounds.
- The scene sets up the concept and prepares for the next scene's step progression.
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: