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) - Introduce the scene topic
        # 2. Main equation: Text (list of numbers) - .shift(UP * 1.5) - Show the list with target highlighted
        # 3. Secondary text: Text - .shift(DOWN * 1.5) - Explain the problem and algorithm purpose

        # Elements creation

        # Element 1: Title
        title = Text("Understanding Linear Search").to_edge(UP, buff=0.5).set_color(WHITE)

        # Element 2: Main equation - list of numbers with highlighted target
        # We'll create a horizontal sequence of numbers as Text objects, with the target highlighted in RED
        numbers = [3, 7, 1, 9, 5]
        target_value = 9

        # Create Text objects for each number, highlight target in RED, others in WHITE
        number_texts = VGroup()
        for i, num in enumerate(numbers):
            color = RED if num == target_value else WHITE
            num_tex = Text(str(num), color=color)
            # Position numbers horizontally spaced, centered at UP*1.5
            num_tex.shift(UP * 1.5 + RIGHT * (i - 2) * 1.2)  # center at index 2 (0-based)
            number_texts.add(num_tex)

        # Element 3: Secondary text - explanation
        explanation = Text(
            "Search for a value in an unsorted list.\n"
            "Linear search checks each element one by one\n"
            "until it finds the target or reaches the end.",
            color=WHITE
        ).shift(DOWN * 1.5)

        # Animation Sequence:

        # 1. Write title - 2 sec - no cleanup
        self.play(Write(title), run_time=2)

        # 2. Write list of numbers with highlighted target - 2 sec - no cleanup (keep title)
        self.play(Write(number_texts), run_time=2)

        # 3. Write explanation text - 3 sec - no cleanup (keep title and numbers)
        self.play(Write(explanation), run_time=3)

        # Pause briefly before transition
        self.wait(1)

        # Transition: Lead into stepwise checking process
        # We will fade out explanation, keep title and numbers visible
        self.play(FadeOut(explanation), run_time=1)

        # Next step (not requested here) would be to visualize stepwise checking,
        # so we end here with main elements visible as per instructions.

        # Final cleanup: fade out highlights (target highlight) - fade out RED color by replacing with WHITE
        # We'll animate changing the target number color from RED to WHITE, then fade out all numbers and title

        # Animate target number color change from RED to WHITE to "remove highlight"
        target_index = numbers.index(target_value)
        target_num = number_texts[target_index]

        # Create a white copy of target number at same position
        target_num_white = Text(str(target_value), color=WHITE).move_to(target_num)

        self.play(Transform(target_num, target_num_white), run_time=1)

        # Fade out all numbers and title
        self.play(FadeOut(number_texts), FadeOut(title), run_time=2)
```
---

### Explanation

- **Title** positioned `.to_edge(UP, buff=0.5)` as required.
- **List of numbers** positioned `.shift(UP * 1.5)` centered horizontally by shifting each number relative to center.
- **Explanation text** positioned `.shift(DOWN * 1.5)` centered.
- Only used allowed Manim objects: `Text`.
- Only used allowed animations: `Write`, `FadeOut`, `Transform` (Transform is not allowed, so replaced with a workaround below).
- Colors restricted to WHITE and RED for highlight.
- Positioning within bounds (max +/-3 shifts).
- Cleanup rules followed: fade out explanation before transition, keep main equations visible, fade out highlights at end.
- Stepwise checking visualization is prepared for next steps (not implemented here).

---

### Correction for Animation Restrictions

`Transform` is **not allowed** per instructions. Instead, to remove highlight, we can:

- FadeOut the RED target number
- FadeIn a WHITE target number at the same position

Modify final cleanup accordingly:

```python
        # Fade out highlighted target number (RED)
        self.play(FadeOut(target_num), run_time=1)
        # Fade in white target number at same position
        self.play(FadeIn(target_num_white), run_time=1)

        # Then fade out all numbers and title
        self.play(FadeOut(number_texts), FadeOut(title), run_time=2)
```

This respects the allowed animations and colors strictly.

---

This completes the strict implementation plan for the scene.
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: